int函数

离散化的定义：离散化，把无限空间中有限的个体映射到有限的空间中去，以此提高算法的时空效率。（by百度百科） 为什么要离散化处理？ 打个比方，某个题目告诉你有10^4个数，每个数大小不超过10^10，要你对这些数进行操作，需要开10^10的数组，当然这是不可能的，但是10^4的范围就完全没问题。 我们可以把这些数映射到一个新的数组中，只改变元素大小，但是不改变其相对大小。 所以离散化只能用在只考虑元素的相对大小，而不考虑元素本身的问题。 离散化操作用到了三个函数 sort, unique, lower_bound. 具体步骤看代码： #include<bits/stdc++.h> using namespace std; const int N=1E5+7; int arr1[N],arr2[N]; int rank[N];//离散化数组 int main(){ int n; cin>>n; for(int i=1;i<=n;i++) { cin>>arr1[i]; arr2[i]=arr1[i]; } sort(arr2+1,arr2+1+n);//首先对arr2排序 int len=unique(arr2+1,arr2+1+n)-arr2-1;//然后是去重以及去重后的大小 for(int i=1;i<=n;i++){ rank[i]=lower_bound(arr2+1

一、 最小乘积(基本型) 【这个题需要认真阅读试题，内容量较大，刚开始的时候，由于练习系统上给出的输入输出的格式有问题，没看懂，最后在MikCu的博客上看到了正确的格式，参考了代码，最终得到正确的结果。为了让结果最小， 可以先分别对两组数进行排序，然后对其中的一组数据逆序，逆序后，把两组数据最大的与最小的相乘，最后求得的和最小！ 】 问题描述 　　给两组数，各n个。 　　请调整每组数的排列顺序，使得两组数据相同下标元素对应相乘，然后相加的和最小。要求程序输出这个最小值。 　　例如两组数分别为:1 3　　-5和-2 4 1 　　那么对应乘积取和的最小值应为： 　　(-5) * 4 + 3 * (-2) + 1 * 1 = -25 输入格式 　 　第一个行一个数T表示数据组数。后面每组数据，先读入一个n，接下来两行每行n个数，每个数的绝对值小于等于1000。 　　n<=8,T<=1000 输出格式 　　一个数表示答案。 样例输入 　　2　　　　//两组数据 　　3　　　　//每行三个数 　　1 3 -5 　　-2 4 1 　　5　　　　//每行五个数 　　1 2 3 4 5 　　1 0 1 0 1 样例输出 　　-25 　　6 1 import java.util.Arrays; 2 import java.util.Scanner; 3 4 public class Main { 5

函数名 函数类型与形参类型 函数功能 函数返回值 clearerr void clearerr(fp) FILE * fp; 清除文件指针错误 无 close int close(fp) int fp; 关闭文件（非ANSI标准） 关闭成功返回0，不成功返回－1 create int create(filename,mode) char * filename; int mode; 以mode所指定的方式建立文件（非ANSI标准） 成功返回正数，否否则返回－1 eof int eof(fd) int fd; 判断文件（非ANSI标准） 是否结束 结束1，否则0 fclose int fclose(fp) FILE *fp; 关闭fp所指的文件，释放文件缓冲区 关闭成功0，否则返回非0 feof int feof(fp) FILE * fp; 检查文件是否结束 文件结束返回非0，否则返回0 ferror int ferror(fp) FILE * fp; 测试fp所指的文件是否有错误 无错返回0，否则返回非0 fflush int fflush(fp) FILE * fp; 将fp所指的文件的全部控制信息和数据存盘 存盘正确返回0，否则返回非0 fgetc int fgetc(fp) FILE * fp; 从fp所指向的文件中取得下一个字符 返回得到的字符，若出错返回EOF fgets

大致思路： 　　初始时，令2是素数，假设2之后奇数全部数都是素数(偶数不考虑会快一点点)，从3开始每当找到一个素数时，显然这个素数乘上另外一个数之后都是合数，把这些合数都筛掉，直到最后一个奇数超出范围，剩下的都是奇数都是素数。 　　注：以下代码只为得到n以内的素数，所以执行后标记数组中的标记是不完整的，如函数1和2中的isPrime[4]=1显然是错的，不过这对prime数组没有影响。如果想使标记数组完整，请自行修改。 前提： 1 #include<bits/stdc++.h> 2 using namespace std; 3 4 const int MN=1e+8; 5 bool isPrime[MN];//isPrime[i]:i是否素数 6 int prime[MN/10];//prime[i]:第i个素数 1.普通筛法： 1 int makePrime1(int n)//求n以内的素数，返回得到的素数个数，下同 2 { 3 memset(isPrime,1,sizeof(isPrime)); 4 memset(prime,0,sizeof(prime)); 5 // 6 prime[1]=2; 7 int cnt=1; 8 for(long long i=3;i<=n;i+=2) 9 { 10 if(isPrime[i]) 11 { 12 prime[++cnt]=i;

1.欧几里得算法 求解最大公约数，时间复杂度在O(log max(a,b))以内，可以看出，辗转相除法是非常高效的 int gcd(int a,int b) { return (b==0)?a:gcd(b,a%b); } 2.扩展欧几里得算法 求解方程a*x+b*y=gcd(a,b)，a、b、x、y均为整数，时间复杂度和辗转相除法是相同的，函数返回gcd(a,b)。 int gcd(int a,int b) { return (b==0)?a:gcd(b,a%b); } int extgcd(int a,int b,int& x,int& y) { int d=a; if(b!=0){ d=extgcd(b,a%b,y,x); y-=(a/b)*x; } else{ x=1; y=0; } return d; } 3.素数测试 //素性测试O(√n) bool is_prime(int n) { for(int i=2;i*i<=n;i++){ if(n%i==0) return false; } return n!=1;//n等于1是例外 } //约数枚举O(√n) vector<int> divisor(int n) { vector<int> res; for(int i=2;i*i<=n;i++){ if(n%i==0){ res.push_back(i); if(i!=n

但在C++中，允许多个函数拥有相同的名字，只要它们的参数列表不同就可以，这就是函数的重载 需满足 函数参数 ： 个数不同 / 参数类型不同，参数顺序不同 才能构成重载 。 //C语言不支持函数重载 下面写法是错误的 extern"C"{ intsum (inta, intb ) { returna + b; } intsum (inta,intb ,intc ) { returna + b + b ; } } //参数个数不同 构成函数重载 void test (int a ,int b ){ } void test (int a) { } //参数类型不同 构成函数重载 void test (int a) { } void test (float a) { } //参数顺序不同，同一方法参数类型不同，构成重载 void test1 (float a ,int b ) { } void test1 (int b , float a ) { } //参数顺序不同，同一方法参数类型相同，无法构成重载 报错： 重复定义 void test2 (int a ,int b ) { } void test2 (int b , int a ) { } //返回值类型无法构成重载 报错： 重复定义 void test3 (int a ,int b ) { } int test3 (int a

题目描述 输入两个整数a,b，输出它们的和(|a|,|b|<=10^9)。 注意： pascal使用integer会爆掉哦！ 有负数哦！ c/c++的main函数必须是int类型，而且最后要return 0。这不仅对洛谷其他题目有效，而且也是noip/noi比赛的要求！ 好吧，同志们，我们就从这一题开始，向着大牛的路进发。 任何一个伟大的思想，都有一个微不足道的开始。 输入输出格式 输入格式： 两个整数以空格分开 输出格式： 一个数 输入输出样例 输入样例： 20 30 输出样例 ： 50 代码实现： #include<iostream> #include<cstdio> using namespace std; int a,b;//快读 inline int read() { int n=0,f=1;char ch=getchar(); while (ch<'0'||ch>'9') {if(ch=='-') f=-1;ch=getchar();} while (ch<='9' && ch>='0') {n=(n<<3)+(n<<1)+ch-'0';ch=getchar();} return n*f; } int main() { a=read(),b=read(); printf("%d",a+b); return 0; } 来源： https://www.cnblogs.com

题目 题目地址： PAT 乙级 1037 题解 本题 有两个版本的代码，初版因为种种问题写得比较繁琐，具体的分析见后文，更新的之后的版本相对来说要好很多，代码也比较清晰简洁。 初版的代码主要有如下几方面的问题： 1. 代码繁琐，把简单的问题复杂化。 2. 刷题一直在用C++，虽说C和C++相似，但是思路一直在框定在C++的范围内，不够灵活。 下面就具体代码进行分析： 代码 1 #include <iostream> 2 #include <string> 3 #include <cmath> 4 using namespace std; 5 6 struct Data { 7 string str; 8 int g; 9 int s; 10 int k; 11 int Q; 12 }; 13 14 int str2int(string s) { 15 int num = 0; 16 int cnt = 0; 17 for (int i = s.size() - 1; i >= 0; i--) { 18 num += (int(s[i]) - 48) * pow(10, cnt); 19 cnt++; 20 } 21 return num; 22 } 23 24 void str2num(Data &s) { 25 int cnt = 0, loc = 0; 26 for (int

/*--> */ /*--> */ /*--> */ /*--> */ /*--> */ /*--> */ /*--> */ /*--> */ 在C++11中,auto关键字被作为类型自动类型推导关键字 (1)基本用法 C++98:类型 变量名 = 初值; int i = 10; C++11:auto 变量名 = 初值; auto i = 3.14; 借助于auto关键字,可对变量进行隐式的类型定义,即由编译器在编译期间根据变量的初始化语句,自动推断出该变量的类型. auto a = 1;//a被推导为int auto b = new auto(2);//b推导为int* auto const *c = &a;// 在旧语法中,auto型变量存储于栈区,static型变量存储于静态区,二者不能同时使用,但c++11的auto关键字已经不再作为存储类型指示符 static auto i = 4; auto int j; //error auto并不能代表一个世纪的类型声明,只是一个类型声明的占位符,使用auto声明的变量必须马上初始化,以让编译器推断出它的实际类型并在编译剪短将auto替换为真的类型 auto k; //error (2)auto同指针或引用结合使用 即使不把auto声明为指针,其亦可被推导为指针类型 int a = 0; auto *b = &a; //auto

//基本内置类型 //char //字符数据类型 //short //短整型 //int //整形 //long //长整型 //long long //更长的整形 //float //单精度浮点数 //double //双精度浮点数 //基本类型归类 // //1整形 //char //unsigned char //signed char //short //unsigned short[int] //signed short[int] //int //unsigned int //signed int //long //unsigned long[int] //signed long[int] //2浮点数家族 //float //double //3构造类型 //> 数组类型 //> 结构体类型 struct //> 枚举类型 enum //> 联合类型 union //4指针类型 //int pi; //char pc; //float pf; //void pv; //5空类型 //void 表示空类型（无类型） //通常应用于函数的返回类型、函数的参数、指针类型 //原码，反码，补码 //1对于负数而言： //原码：直接将二进制按照正负数的形式翻译成二进制就可以。 //反码：将原码的符号位不变，其他位依次按位取反就可以得到了。 //补码：反码 + 1就得到补码。 /