线性求逆元模板_ZXBlog/ACM模板(C++).md at bb6f2522054d5370df79222461293721e8edede2 · cw1027/ZXBlog · GitHub...
ACM模板(C++)
1、大数
加法，乘法模板
//题目链接 : http://poj.org/problem?id=2506
//题目大意 : 就是问你用2*1,1*2,2*2的砖拼成2*n的长方形,有多少种拼法
//解题思路 : 考虑n的时候,假设我们已经铺好了n-1块砖,第n块只能竖着放
//假设我们已经铺好了n-2块砖,最后两列有3种方式,但是其中有一种方法和上面是相同的
//所以f[n] = 2* f[n-2] + f[n-1]
#include
#include
#include
using namespace std;
const int maxn = 10000 + 10;
//加法
string bigIntegerAdd(string s1,string s2){
int a[maxn],b[maxn];
memset(a,0,sizeof(a));
memset(b,0,sizeof(b));
int len1 = s1.size(),len2 = s2.size();
int maxL = max(len1,len2);
for(int i = 0; i < len1; i++)a[i] = s1[len1-1-i]-'0';
for(int i = 0; i < len2; i++)b[i] = s2[len2-1-i]-'0';
for(int i = 0; i < maxL; i++){
if(a[i]+b[i] >= 10){
int temp = a[i]+b[i];
a[i] = temp%10;
a[i+1] += (temp/10);
}
else a[i] += b[i];
}
string c = "";
if(a[maxL] != 0)
c += a[maxL] + '0';
for(int i = maxL-1; i >= 0; i--)c += a[i] + '0';
return c;
}
//乘法
string bigIntegerMul(string s1,string s2){
int a[maxn],b[maxn],c[maxn*2 + 5];
memset(a,0,sizeof(a));
memset(b,0,sizeof(b));
memset(c,0,sizeof(c));
int len1 = s1.size(),len2 = s2.size();
for(int i = 0; i < len1; i++)a[i] = s1[len1-1-i]-'0'; //倒置
for(int i = 0; i < len2; i++)b[i] = s2[len2-1-i]-'0';
for(int i = 0; i < len1; i++){
for(int j = 0; j < len2; j++){
c[i+j] += a[i]*b[j];
}
}
for(int i = 0; i < maxn*2; i++){
if(c[i] >= 10){
c[i+1] += c[i]/10;
c[i] %= 10;
}
}
string ans = "";
int i;
for(i = maxn * 2; i >= 0; i--)
if(c[i] != 0)
break;
for(;i >= 0; i--)ans += c[i] + '0';
return ans;
}
int main(){
//freopen("in.txt","r",stdin);
int n;
string s[255];
s[0] = "1",s[1] = "1"; //注意0的时候是1
for(int i = 2;i <= 255; i++){
string temp = bigIntegerMul("2",s[i-2]);
s[i] = bigIntegerAdd(s[i-1],temp);
}
while(~scanf("%d",&n))
cout<
return 0;
}
减法模板
#include
const int maxn = 200 + 10;
using namespace std;
typedef long long LL;
//具体实现
string subInfo(char *s1,char *s2){
int a[maxn],b[maxn];
memset(a,0,sizeof(a));
memset(b,0,sizeof(b));
int len1 = strlen(s1),len2 = strlen(s2);
int maxLen = max(len1,len2);
for(int i = 0; i < len1; i++) a[i] = s1[len1 - i - 1] - '0';
for(int i = 0; i < len2; i++) b[i] = s2[len2 - i - 1] - '0';
for(int i = 0; i < maxLen; i++){
if(a[i]-b[i] < 0){
a[i] = a[i]+10-b[i];
a[i+1] -= 1;
}
else a[i] -= b[i];
}
string str = "";
int i;
for(i = maxLen-1; i >= 0; i--)if(a[i] != 0)break;
for(;i >= 0; i--)str += a[i]+'0';
return str;
}
//大数减法的模板
string bigIntegerSub(char *s1,char *s2){
if(s1 == s2)
return "0"; //相等
int len1 = strlen(s1),len2 = strlen(s2);
if(len1 > len2)
return subInfo(s1,s2);
else if(len1 < len2)
return "-" + subInfo(s2,s1); //负数
else { //长度相等时判断大小
for(int i = 0; i < len1; i++){
if(s1[i]-'0' > s2[i]-'0')
return subInfo(s1,s2);
else if(s1[i]-'0' < s2[i]-'0')
return "-" + subInfo(s2,s1);
}
}
}
int main(){
char s1[maxn],s2[maxn];
scanf("%s\n%s",s1,s2);
cout<
return 0;
}
求阶乘以及位数模板
//http://acm.nyist.edu.cn/JudgeOnline/problem.php?pid=28
//大数阶乘的模板
#include
using namespace std;
const int maxn = 100000 + 10;
//大数计算阶乘位数
//lg(N!)=[lg(N*(N-1)*(N-2)*......*3*2*1)]+1 = [lgN+lg(N-1)+lg(N-2)+......+lg3+lg2+lg1]+1;
int factorialDigit(int n){
double sum = 0;
for(int i = 1; i <= n; i++){
sum += log10(i);
}
return (int)sum+1;
}
//大数计算阶乘
string bigFactorial(int n){
int ans[maxn],digit = 1;
ans[0] = 1;
for(int i = 2; i <= n; i++){
int num = 0;
for(int j = 0; j < digit; j++){
int temp = ans[j]*i + num;
ans[j] = temp%10;
num = temp/10;
}
while(num != 0){
ans[digit] = num%10;
num /= 10;
digit++;
}
}
string str = "";
for(int i = digit-1; i >= 0; i--)
str += ans[i] + '0';
return str;
}
int main(){
int n;
while(~scanf("%d",&n)){
//cout<
cout<
}
return 0;
}
二分
二分的写法可以有很多种，这里列举几个常见的，主要是上界确定，区间以及查找元素是否重复的问题，也可以看看这篇文章。
求最小的i，使得a[i] = key，若不存在，则返回-1(lowerbound函数)；
求最大的i的下一个元素的下标(c++中的upperbound函数)，使得a[i] = key，若不存在，则返回-1；
求最大的i，使得a[i] = key，若不存在，则返回-1；
求最小的i，使得a[i] > key，若不存在，则返回-1；
求最大的i，使得a[i] < key，若不存在，则返回-1；
#include
using namespace std;
const int maxn = 100 + 10;
int cmp(const void *a, const void *b) {
return *(int *) a - *(int *) b;
}
//普通的二分查找
int bs(int *arr,int L,int R,int target){
while( L <= R){
int mid = (L) + (R-L)/2;
if(arr[mid] == target)
return mid;
if(arr[mid] > target)
R = mid - 1;
else
L = mid + 1;
}
return -1; // not find
}
//求最小的i，使得a[i] = target，若不存在，则返回-1
//返回 如果有重复的 下界(比如1,2,2,2,3,4)查找2,返回1
int firstEqual(int arr[], int L, int R, int target) {
while (L < R) {
int mid = L + (R - L) / 2;
if (arr[mid] < target)
L = mid + 1;
else
R = mid;
}
if (arr[L] == target)
return L;
return -1;
}
//求最大的i的下一个元素的下标(c++中的upperbound函数)，使得a[i] = target，若不存在，则返回-1
int lastEqualNext(int arr[], int L, int R, int target) {
while (L < R) {
int m = L + (R - L) / 2;
if (arr[m] <= target)
L = m + 1;
else
R = m;
}
if (arr[L - 1] == target)
return L;
return -1;
}
//求最大的i，使得a[i] = target，若不存在，则返回-1
int lastEqual(int arr[], int L, int R, int target) {
while (L < R) {
int mid = L + ((R + 1 - L) >> 1);//向上取整
if (arr[mid] <= target)
L = mid;
else
R = mid - 1;
}
if (arr[L] == target)
return L;
return -1;
}
//求最小的i，使得a[i] > target，若不存在，则返回-1
int firstLarge(int arr[], int L, int R, int target) {
while (L < R) {
int m = L + ((R - L) >> 1);//向下取整
if (arr[m] <= target)
L = m + 1;
else
R = m;
}
if (arr[R] > target)
return R;
return -1;
}
//求最大的i，使得a[i] < target，若不存在，则返回-1
int lastSmall(int arr[], int L, int R, int target) {
while (L < R) {
int m = L + ((R + 1 - L) >> 1);//向上取整
if (arr[m] < target)
L = m;
else
R = m - 1;
}
if (arr[L] < target)
return L;
return -1;
}
int main() {
//freopen("in.txt", "r", stdin);
int n, a[maxn], v;
scanf("%d", &n);
for (int i = 0; i < n; i++)scanf("%d", &a[i]); //1 3 2 9 4 1 3 7 2 2
scanf("%d", &v); //input the number you need find
qsort(a, n, sizeof(a[0]), cmp); // 1 1 2 2 2 3 3 4 7 9
printf("after sorted : \n");
for (int i = 0; i < n; i++)printf("%d ", a[i]);
printf("\n-------------test----------------");
printf("\n%d\n", firstEqual(a, 0, n, v)); //output 2 第一个
printf("%d\n", lastEqualNext(a, 0, n, v)); //output 4 + 1,最后一个的下一个
printf("%d\n", lastEqual(a, 0, n, v)); //output 4 最后一个
printf("%d\n", firstLarge(a, 0, n, v)); //output 5(第一个3大于2)
printf("%d\n", lastSmall(a, 0, n, v)); //output 1(不是0)
return 0;
}
/*
测试数据:
10
1 3 2 9 4 1 3 7 2 2
2
*/
输出
枚举排列
枚举排列的算法也有几个，包括刘汝佳书上的和经典的，还有做过的几个题LeetCode47。LeetCode46。
#include
using namespace std;
const int maxn = 100 + 10;
void permutation(int *arr, int n, int cur){
if(cur == n){ // 边界
for(int i = 0; i < n; i++)
printf("%d ",arr[i]);
printf("\n");
}
else for(int i = 1; i <= n; i++){ //尝试在arr[cur]中填充各种整数
bool flag = true;
for(int j = 0; j < cur; j++)if(i == arr[j]){ // 如果i已经在arr[0]~arr[cur-1]中出现过，则不能选
flag = false;
break;
}
if(flag){
arr[cur] = i; //把i填充到当前位置
permutation(arr, n, cur+1);
}
}
}
// 求 1 ~ n 的全排列，arr数组作为中间打印数组
int main(int argc, char const **argv)
{
int a[maxn], n;
scanf("%d", &n);
permutation(a, n, 0);
return 0;
}
//可重集的全排列
#include
const int maxn = 100 + 10;
void permutation(int *arr,int *p,int n,int cur){
if(cur == n){
for(int i = 0; i < n; i++)
printf("%d ",arr[i]);
printf("\n");
}else for(int i = 0; i < n; i++)if(!i || p[i] != p[i-1]){
int c1 = 0, c2 = 0;
for(int j = 0; j < n; j++)
if(p[j] == p[i]) // 重复元素的个数
c1++;
for(int j = 0; j < cur; j++)
if(arr[j] == p[i]) // 前面已经排列的重复元素的个数
c2++;
if(c2 < c1){
arr[cur] = p[i];
permutation(arr, p, n, cur+1);
}
}
}
int main(){
int a[maxn], p[maxn] = {5, 6, 7, 5}; //可以有重复元素的全排列
std::sort(p, p+4);
permutation(a, p, 4, 0);
return 0;
}
//全排列的非去重递归算法
#include
using namespace std;
const int maxn = 100 + 10;
void permutation(int arr[], int cur, int n){
if( cur == n){
for(int i = 0; i < n; i++)
printf("%d ", arr[i]);
printf("\n");
}
else for(int i = cur; i < n; i++){
swap(arr[i], arr[cur]);
permutation(arr, cur+1, n);
swap(arr[i], arr[cur]);
}
}
int main(){
int n, a[maxn];
scanf("%d", &n);
for(int i = 0; i < n; i++)
scanf("%d", &a[i]);
permutation(a, 0, n);
return 0;
}
子集生成
增量构造法，位向量法，二进制法(常用)
#include
using namespace std;
const int maxn = 100 + 10;
//打印0~n-1的所有子集
//按照递增顺序就行构造子集 防止子集的重复
void print_subset(int *arr, int n, int cur){
for(int i = 0; i < cur; i++)
printf("%d ", arr[i]);
printf("\n");
int s = cur ? arr[cur-1] + 1 : 0; //确定当前元素的最小可能值
for(int i = s; i < n; i++){
arr[cur] = i;
print_subset(arr, n, cur+1);
}
}
int main(){
int n, arr[maxn];
scanf("%d", &n);
print_subset(arr, n, 0);
return 0;
}
这个其实很简单，就是枚举每个位置0和1两种情况即可。
// 1~n 的所有子集：位向量法
#include
const int maxn = 100 + 10;
using namespace std;
int bits[maxn];//位向量bits[i] = 1,当且仅当i在子集 A 中
void print_subset(int n,int cur){
if(cur == n){
for(int i = 0; i < cur; i++)
if(bits[i])
printf("%d ",i);
printf("\n");
return;
}
bits[cur] = 1;
print_subset(n,cur + 1);
bits[cur] = 0;
print_subset(n,cur + 1);
}
int main() {
int n;
scanf("%d", &n);
print_subset(n,0);
return 0;
}
二进制枚举子集用的多，这里举个例子 n = 3；则要枚举0 - 7 对应的是有7个子集，每个子集去找有哪些元素print_subset中的 1<< i，也就是对应的那个位置是有元素的，例如1的二进制是0001也就是代表0位置有元素，0010是2，代表第一个位置是1，0100代表第2个位置上有元素，相应的1000 = 8对应第3个位置上有元素。
总结来说也就是对应1<< i对应i上是1(从0开始)，其余位置是0。看图容易理解：
// 0 ~ n-1的所有子集：二进制法枚举0 ~ n-1的所有子集
#include
const int maxn = 100 + 10;
using namespace std;
void print_subset(int n,int cur){
//这一步其实就是判断 cur 的二进制的各个位上是不是1，如果是1,就输出对应的那个位置(位置从0开始)
for(int i = 0; i < n; i++)
if(1 & (cur >> i))
printf("%d ",i);
printf("\n");
}
int main(int argc, char const** argv)
{
int n;
scanf("%d",&n);
for(int i = 0; i < (1 << n); i++)
print_subset(n,i);//枚举各子集对应的编码 0,1,2...pow(2,n) - 1
return 0;
}
n皇后回溯
可以看这篇博客。
//n皇后问题：普通回溯法
#include
const int maxn = 100 + 10;
using namespace std;
int sum,n,cnt; //解的个数，n皇后，递归次数
int C[maxn];
void Search(int cur){ //逐行放置皇后
cnt++;
if(cur == n)sum++;
else for(int i = 0; i < n; i++){ //尝试在各列放置皇后
bool flag = true;
C[cur] = i; //尝试把第cur行的皇后放在第i列//如果 等下不行的话 就下一个 i++
for(int j = 0; j < cur; j++){ //检查是否和已经放置的冲突
if(C[cur] == C[j] || C[cur] + cur == C[j] + j || cur - C[cur] == j - C[j]){//检查列,"副对角线","主对角线"
flag = false;break;
}
}
if(flag)Search(cur+1);
}
}
int main(){
scanf("%d",&n); //输入n皇后
sum = cnt = 0;//解的个数 和 递归的次数
Search(0);
printf("%d %d\n",sum,cnt);
return 0;
}
优化过的
// n皇后问题：优化的回溯法
#include
const int maxn = 100 + 10;
using namespace std;
int sum,n,cnt;
int C[maxn];
bool vis[3][maxn];
int Map[maxn][maxn];//打印解的数组
//一般在回溯法中修改了辅助的全局变量，一定要及时把他们恢复原状
void Search(int cur){ //逐行放置皇后
cnt++;
if(cur == n){
sum++;
for(int i = 0; i < cur; i++)Map[i][C[i]] = 1;//打印解
for(int i = 0; i < n; i++){
for(int j = 0; j < n; j++)printf("%d ",Map[i][j]);
printf("\n");
}
printf("\n");
memset(Map,0,sizeof(Map)); //还原
}
else for(int i = 0; i < n; i++){ //尝试在 cur行的 各 列 放置皇后
if(!vis[0][i] && !vis[1][cur+i] && !vis[2][cur-i+n]){//判断当前尝试的皇后的列、主对角线
vis[0][i] = vis[1][cur+i] = vis[2][cur-i+n] = true;
C[cur] = i;//cur 行的列是 i
Search(cur+1);
vis[0][i] = vis[1][cur+i] = vis[2][cur-i+n] = false;//切记！一定要改回来
}
}
}
int main(){
scanf("%d",&n);
memset(vis,false,sizeof(vis));
memset(Map,0,sizeof(Map));
sum = cnt = 0;
Search(0);
printf("%d %d\n",sum,cnt);//输出 解决方案 和 递归次数
return 0;
}
并查集
并查集详细讲解以及每一步的优化可以看这篇博客。
//题目连接 : http://poj.org/problem?id=1611
//题目大意 : 病毒传染，可以通过一些社团接触给出一些社团(0号人物是被感染的)问有多少人(0~n-1个人)被感染
#include
const int maxn = 100000 + 10;
int parent[maxn], rank[maxn]; //parent[]保存祖先,rank记录每个'树的高度'
void init(){
for(int i = 0; i < maxn; i++)parent[i] = i; //注意这里
for(int i = 0; i < maxn; i++)rank[i] = 1;
}
//int findRoot(int v){
// return parent[v] == v ? v : parent[v] = findRoot(parent[v]);
//}
// 非递归
int findRoot(int v){
while(parent[v] != v){
parent[v] = parent[parent[v]]; // 路径压缩
v = parent[v];
}
return v;
}
void unions(int a, int b){
int aRoot = findRoot(a);
int bRoot = findRoot(b);
if (aRoot == bRoot)
return;
if (rank[aRoot] < rank[bRoot])
parent[aRoot] = bRoot;
else if(rank[aRoot] > rank[bRoot]){
parent[bRoot] = aRoot;
}else{
parent[aRoot] = bRoot;
rank[bRoot]++;
}
}
int is_same(int x,int y){ //检查是不是在同一个集合中
return findRoot(x) == findRoot(y);
}
int main(){
int n,m,k,x,root;
while(~scanf("%d%d",&n,&m) && (n||m)){
init();
for(int i = 0; i < m; i++){
scanf("%d%d",&k,&root);
for(int j = 1; j < k; j++){
scanf("%d",&x);
unions(root,x);
}
}
int sum = 1;
for(int i = 1; i < n; i++)
if(findRoot(i) == findRoot(0))
sum++; //找和0是一个集合的
printf("%d\n",sum);
}
return 0;
}
树状数组
树状数组的主要用于需要频繁的修改数组元素，同时又要频繁的查询数组内任意区间元素之和的时候。具体一些解释看图。
所以计算2^k次方我们可以用如下代码
int lowbit(int x){
return x&(-x); //或者 return x&(x^(x-1));
}
这里给出一个例题POJ2352Stars
题目意思就是给你一些星星的坐标，每个星星的级别是他左下方的星星的数量，要你求出各个级别的星星有多少个，看样例就懂了
题目中一个重要的信息就是输入是按照y递增，如果y相同则x递增的顺序给出的，所以，对于第i颗星星，它的level就是之前出现过的星星中，横坐标小于等于i的星星的数量。这里用树状数组来记录所有星星的x值。
代码中有个小细节就是x++这是因为lowbit不能传值为0，否则会陷入死循环。
#include
#include
const int maxn = 32000 + 10;
int n,c[maxn],level[15000+10];
//计算2^k
int lowbit(int x){
return x&(-x);
}
//更新数组的值
void update(int i,int val){
while(i < maxn){ //注意这里是最大的x,没有记录所以用maxn,不能用n
c[i] += val;
i += lowbit(i); //不断的往上面更新
}
}
//查询
int sum(int i){
int s = 0;
while(i > 0){
s += c[i];
i -= lowbit(i); //不断的往下面加
}
return s;
}
int main(){
int x,y;
scanf("%d",&n);
memset(c,0,sizeof(c));
memset(level,0,sizeof(level));
for(int i = 0; i < n; i++){
scanf("%d%d",&x,&y);
x++; //加入x+1，是为了避免0，X是可能为0的,LOWBIT无法处理0的情况，因为它的结果也是0，那么最终就是一个死循环
level[sum(x)]++;
update(x,1); //上面的层都要+1个
}
for(int i = 0; i < n; i++)
printf("%d\n",level[i]);
return 0;
}
KMP，Sunday，BM
这三个算法解决的问题都是 : 有一个文本串 S，和一个模式串 P，现在要查找 P 在 S 中的位置，三种算法的思路这里限于篇幅不多说，这篇博客对着三种算法讲解的比较详细。
KMP的较直观的分析也可以看看我的另一篇博客
```cpp
//题目连接 : http://acm.hdu.edu.cn/showproblem.php?pid=1711
//题目大意 : 找第二个数组在第一个数组中出现的位置，如果不存在，输出-1
#include
const int maxn = 1000000 + 10;
int n,m,a[maxn], b[10000 + 10],nexts[10000 + 10];
void getNext(int *p,int next[]) { //优化后的求next数组的方法
int len = m;
next[0] = -1; //next 数组中的 最大长度值(前后缀的公共最大长度) 的第一个 赋值为 -1
int k = -1,j = 0;
while (j < len - 1) {
if (k == -1 || p[j] == p[k]) { //p[k]表示前缀 p[j] 表示后缀
k++; j++;
if(p[j] != p[k])next[j] = k;
else next[j] = next[k]; //因为不能出现p[j] = p[ next[j ]]，所以当出现时需要继续递归，k = next[k] = next[next[k]]
}
else k = next[k];
}
}
int KMPSerach(int *s, int *p) {
int sLen = n,pLen = m;
int i = 0, j = 0;
while (i < sLen && j < pLen) {
if (j == -1 || s[i] == p[j])i++, j++;
else j = nexts[j];
}
if (j == pLen)return i - j;
else return -1;
}
int main() {
int T;
scanf("%d", &T);
while (T--) {
scanf("%d%d", &n, &m);
for(int i = 0; i < n; i++)scanf("%d", &a[i]);
for(int i = 0; i < m; i++)scanf("%d", &b[i]);
getNext(b,nexts); //获取next数组
int ans = KMPSerach(a, b);
if (ans != -1)printf("%d\n", ans + 1);
else printf("-1\n");
}
return 0;
}
**`BM`算法，主要是根据两个规则去执行**
```cpp
//题目链接：http://acm.hrbust.edu.cn/index.php?m=ProblemSet&a=showProblem&problem_id=1551
//题目大意：找一串字符中是否出现"bkpstor"这段字符
#include
#include
#include
using namespace std;
const int maxn = 1000;
int last(char *p, char c) { //找到文本串的 "坏字符" 在模式串中的位置
for (int i = strlen(p) - 1; i >= 0; i--)if (p[i] == c)return i;
return -1;
}
int BM_index(char *T, char *p) {
int n = strlen(T);
int m = strlen(p);
int i = m - 1, j = m - 1;
while (i <= n - 1) {
if (T[i] == p[j])
if (j == 0)return i;
else i--, j--;
else {
i = i + m - min(j, 1 + last(p, T[i]));//文本的不符合的那个 位置 串移动的步数
j = m - 1;//模式串的新位置
}
}
return -1;
}
int Sum(char *T, char *P, int s) {//输出文本串中包含模式串的数量
int e = BM_index(T + s, P);
return e == -1 ? 0 : 1 + Sum(T, P, s + e + 1);
}
//测试数据 : 123bkpstor456bkpstor67
int main() {
char s[maxn];
while (~scanf("%s",s)) {
int cnt = BM_index(s, "bkpstor");
//printf("%d\n",Sum(s,"bkpstor",0));出现次数输出2
if (cnt == -1)printf("Safe\n");
else printf("Warning\n");
}
return 0;
}
Sunday算法也是两个规则
//题目链接：http://acm.hrbust.edu.cn/index.php?m=ProblemSet&a=showProblem&problem_id=1551
//题目大意: 找一串字符中是否出现"bkpstor"这段字符
#include
#include
#include
const int maxn = 1000;
using namespace std;
int last(char *p, char c) {
for (int i = strlen(p) - 1; i >= 0; i--)if (p[i] == c)return i;
return -1;
}
int Sunday(char *s, char *p) {
int sLen = strlen(s);
int pLen = strlen(p);
int i = 0, j = 0;
while (i < sLen && j < pLen) {
if (s[i] == p[j])i++, j++;
else {
int index = i + pLen - j; // 字符串中右端对齐的字符
if (last(p, s[index]) == -1) { i = index + 1; j = 0; } // 没有在匹配串中出现则直接跳过
else {
i = index - last(p, s[index]); j = 0; //否则 其移动步长 = 匹配串中最 右端 的该字符到末尾的距离 + 1。
}
}
}
if (j == pLen)return i - j;
return -1;
}
int main() {
char s[maxn];
while (~scanf("%s",s)) {
int cnt = Sunday(s,"bkpstor");
if (cnt == -1)printf("Safe\n");
else printf("Warning\n");
}
return 0;
}
01背包，完全背包
背包问题可以分为很多种，这里只简单讨论01背包和完全背包，
后来改写的01背包: 博客
参考博客：
//题目连接 : http://acm.hdu.edu.cn/showproblem.php?pid=2602
#include
#include
#include
using namespace std;
const int maxn = 1000+5;
int w[maxn],v[maxn],dp[maxn][maxn],vis[maxn];
//打印解
void print(int n,int C){
for(int i = n; i > 1; i--){
if(dp[i][C] == dp[i-1][C-w[i]] + v[i]){
vis[i] = 1;
C -= w[i];
}
}
vis[1] = (dp[1][C] > 0) ? 1: 0;
}
int main(){
freopen("in.txt","r",stdin);
int n,C,T;
scanf("%d",&T);
while(T--){
scanf("%d%d",&n,&C);
for(int i = 1;i <= n; i++) scanf("%d",&v[i]);
for(int i = 1;i <= n; i++) scanf("%d",&w[i]);
memset(dp,0,sizeof(dp)); //dp[0][0~C]和dp[0~N][0]都为0，前者表示前0个物品无论装入多大的包中总价值都为0，后者表示体积为0的背包都装不进去。
memset(vis,0,sizeof(vis));
for(int i = 1; i <= n; i++){
for(int j = 0;j <= C; j++){
dp[i][j] = dp[i-1][j]; //如果j不大于v[i]的话就dp[i][j] = dp[i-1][j];
if(j >= w[i]) dp[i][j] = max(dp[i][j],dp[i-1][j-w[i]]+v[i]);
}
}
printf("%d\n",dp[n][C]); //n个物品装入C容量的包能获得的最大价值
//print(n,C);
//for(int i = 1; i <= n; i++)if(vis[i])printf("%d ",i); //输出选中的物品
}
return 0;
}
#include
#include
#include
const int maxn = 1000+5;
using namespace std;
int w[maxn],v[maxn],dp[maxn][maxn];
int main(){
int T,n,C;
scanf("%d",&T);
while(T--){
scanf("%d%d",&n,&C);
for(int i = 1; i <= n; i++)scanf("%d",&v[i]);
for(int i = 1; i <= n; i++)scanf("%d",&w[i]);
memset(dp,0,sizeof(dp)); //dp全部初始化为0
for(int i = n;i >= 1; i--){
for(int j = 0; j <= C; j++){
dp[i][j] = (i == n ? 0 : dp[i+1][j]);
if(j >= w[i])dp[i][j] = max(dp[i][j],dp[i+1][j-w[i]]+v[i]);
}
}
printf("%d\n",dp[1][C]);
}
return 0;
}
#include
#include
#include
const int maxn = 1000+5;
using namespace std;
int w[maxn],v[maxn],dp[maxn];
int main(){
int T,n,C;
scanf("%d",&T);
while(T--){
scanf("%d%d",&n,&C);
for(int i = 1; i <= n; i++)scanf("%d",&v[i]);
for(int i = 1; i <= n; i++)scanf("%d",&w[i]);
memset(dp,0,sizeof(dp));
for(int i = 1; i <= n; i++){
for(int j = C;j >= 0; j--){
if(j >= w[i])dp[j] = max(dp[j],dp[j-w[i]]+v[i]);
}
}
printf("%d\n",dp[C]);
}
return 0;
}
完全背包和01背包的差别在于每个物品的数量有无数个，在考虑第i件物品的时候，不是考虑选不选这件，而是选多少件可以达到最大价值
for (int i = 1; i < n; i++){
for (int j = 1; j <= v; j++){
for (int k = 0; k*c[i] <= j; k++){
if(c[i] <= j) dp[i][j] = max{dp[i-1][j],dp[i-1][j - k * c[i]] + k * w[i]};/*要么不取，要么取0件、取1件、取2件……取k件*/
else dp[i][j] = dp[i-1][j]/*继承前i个物品在当前空间大小时的价值*/
}
}
}
优化:
注意完全背包的顺序问题 ：因为每种背包都是无限的。当我们把i从1到N循环时，dp[v]表示容量为v在前i种背包时所得的价值，这里我们要添加的不是前一个背包，而是当前背包。所以我们要考虑的当然是当前状态。为01背包中要按照v=V..0的逆序来循环。这是因为要保证第i次循环中的状态dp[i][v]是由状态dp[i-1] [v-c[i]]递推而来。这正是为了保证每件物品只选一次，保证在考虑“选入第i件物品”这件策略时，依据的是一个绝无已经选入第i件物品的 子结果dp[i-1][v-c[i]]。而现在完全背包的特点恰是每种物品可选无限件，所以在考虑“加选一件第i种物品”这种策略时，却正需要一个可能已选入第i种物品的子结果dp[i][v-c[i]]，所以就可以并且必须采用v=0..V的顺序循环。
完全背包还有考虑是否要求恰好放满背包等问题，可以好好研究：
参考博客:
https://blog.csdn.net/Thousa_Ho/article/details/78156678
https://wenku.baidu.com/view/eea4a76b0b1c59eef8c7b497.html
https://www.cnblogs.com/shihuajie/archive/2013/04/27/3046458.html
#include
#include
#include
using namespace std;
const int maxn = 50000 + 10;
const int INF = -0X7ffff;
int w[maxn],v[maxn],dp[maxn];
int main(){
int T,n,C;
scanf("%d",&T);
while(T--){
scanf("%d%d",&n,&C);
for(int i = 1; i <= C; i++)dp[i] = INF;
dp[0] = 0;
for(int i = 0; i < n; i++)scanf("%d%d",&w[i],&v[i]);
for(int i = 0; i < n; i++){
for(int j = w[i]; j <= C; j++){ //从前往后递推，这样才能保证一种物品可以被使用多次
dp[j] = max(dp[j],dp[j-w[i]] + v[i]);
}
}
if(dp[C] > 0)printf("%d\n",dp[C]);
else printf("NO\n");
}
return 0;
}
最长(不)上升或下降子序列
Java编写与解释的博客。
先说O(N*N)的解法，第i个元素之前的最长递增子序列的长度要么是1(单独成一个序列)，要么就是第i-1个元素之前的最长递增子序列加1，这样得到状态方程：
LIS[i] = max{1,LIS[k]+1} (∀k arr[k])
这样arr[i]才能在arr[k]的基础上构成一个新的递增子序列。
//题目连接 : http://acm.nyist.edu.cn/JudgeOnline/problem.php?pid=17
#include
#include
#include
using namespace std;
const int maxn = 10000 + 10;
int dp[maxn]; /* dp[i]记录到[0,i]数组的LIS */
int maxx;/* LIS长度，初始化为1 */
int LIS(char *arr, int n) {
for (int i = 0; i < n; i++) {
dp[i] = 1;
for (int j = 0; j < i; j++) // 注意i只遍历比它小的元素
if (arr[j] < arr[i]) dp[i] = max(dp[i], dp[j] + 1); //改成arr[j] <= arr[i]就可以求非减的
maxx = max(maxx, dp[i]);
}
return maxx;
}
/* 递归输出LIS，因为数组dp还充当了“标记”作用 */
void printLis(char *arr, int index) {
bool isLIS = false;
if (index < 0 || maxx == 0)return;
if (dp[index] == maxx) {
--maxx;
isLIS = true;
}
printLis(arr, --index);
if (isLIS) printf("%c ", arr[index + 1]);
}
int main() {
char s[maxn];
int n;
scanf("%d\n",&n);
while(n--){
maxx = 1;
scanf("%s",s);
printf("%d\n",LIS(s,strlen(s)));
//printLis(s,strlen(s)-1);printf("\n");
}
return 0;
}
//题目连接 : http://poj.org/problem?id=3903
#include
#include
#include
#include
using namespace std;
const int INF = 0x3f3f3f3f;
const int maxn = 100000 + 5;
int a[maxn], dp[maxn], pos[maxn], fa[maxn];
vector ans;
//用于最长非递减子序列种的lower_bound函数
int cmp(int a,int b){
return a <= b;
}
//最长上升子序列
//dp[i]表示长度为i+1的上升子序列的最末尾元素 找到第一个比dp末尾大的来代替
int LIS(int n){
memset(dp, 0x3f, sizeof(dp));
pos[0] = -1;
int i,lpos;
for (i = 0; i < n; ++i){
dp[lpos = (lower_bound(dp, dp + n, a[i]) - dp)] = a[i];
pos[lpos] = i; // *靠后打印
fa[i] = (lpos ? pos[lpos - 1] : -1);
}
n = lower_bound(dp, dp + n, INF) - dp;
for (i = pos[n - 1]; ~fa[i]; i = fa[i]) ans.push_back(a[i]);
ans.push_back(a[i]);
return n;
}
//非递减的LIS
int LISS(int n){
memset(dp, 0x3f, sizeof(dp));
pos[0] = -1;
int i,lpos;
for (i = 0; i < n; i++){
dp[lpos = (lower_bound(dp, dp + n, a[i],cmp) - dp)] = a[i]; //注意这里cmp
pos[lpos] = i; // *靠后打印
fa[i] = (lpos ? pos[lpos - 1] : -1);
}
n = lower_bound(dp, dp + n, INF) - dp;
for (i = pos[n - 1]; ~fa[i]; i = fa[i]) ans.push_back(a[i]);
ans.push_back(a[i]);
return n;
}
int main(){
// freopen("in.txt","r",stdin);
int n;
while(~scanf("%d",&n)){
ans.clear();
for(int i = 0;i < n; i++)scanf("%d",&a[i]);
printf("%d\n",LIS(n));
// for(int i = ans.size()-1; i >= 0; i--) printf("%d ",ans[i]);printf("\n"); //路径打印
}
return 0;
}
最长公共子序列
最长公共子序列利用动态规划的方式解决，具有最优子结构性质，和重叠子问题性质，dp[i][j]记录序列Xi和Yi的最长公共子序列的长度，当i = 0或j =0 时，空序列时Xi和Yi的最长公共子序列，其余情况如下
这里也给出一篇讲的好的博客
//题目连接 : http://poj.org/problem?id=1458
#include
#include
#include
using namespace std;
const int maxn = 1000 + 10;
int dp[maxn][maxn];
int path[maxn][maxn]; //记录路径
int LCS(char *s1,char *s2){
int len1 = strlen(s1)-1,len2 = strlen(s2)-1;//注意例如 abcfbc的strlen(s1)为7,所以是strlen(s1) - 1
for(int i = 0; i <= len1; i++) dp[i][0] = 0;
for(int i = 0; i <= len2; i++) dp[0][i] = 0;
for(int i = 1; i <= len1; i++){
for(int j = 1; j <= len2; j++)
if(s1[i] == s2[j]){
dp[i][j] = dp[i-1][j-1] + 1;
path[i][j] = 1;
}
else if(dp[i-1][j] >= dp[i][j-1]) {
dp[i][j] = dp[i-1][j];
path[i][j] = 2;
}
else {
dp[i][j] = dp[i][j-1];
path[i][j] = 3;
}
}
return dp[len1][len2];
}
//打印解
void print(int i,int j,char *s){
if(i == 0 || j == 0)return ;
if(path[i][j] == 1){
print(i-1,j-1,s);
printf("%c ",s[i]);
}else if(path[i][j] == 2){
print(i-1,j,s);
}else print(i,j-1,s);
}
int main(){
char s1[maxn],s2[maxn];
while(~scanf("%s%s",s1+1,s2+1)){ //注意s1[0]不取-注意例如 abcfbc的strlen(s1)为7
memset(path,0,sizeof(path));
printf("%d\n",LCS(s1,s2));
//print(strlen(s1)-1,strlen(s2)-1,s1);
}
return 0;
}
拓扑排序
有向无环图上的一种排序方式，我的这篇博客也讲解了一下。可以两种写法:
//题目链接 : https://vjudge.net/contest/169966#problem/O
#include
using namespace std;
const int maxn = 100 + 10;
int n, m;
int in[maxn];
vectorG[maxn];
void topo(){
queueq;
for(int i = 1; i <= n ; i++)
if(in[i] == 0)
q.push(i);
bool flag = true;
while(!q.empty()){
int cur = q.front();
q.pop();
if(flag){
printf("%d",cur);
flag = false;
}
else
printf(" %d",cur);
for(int i = 0; i < G[cur].size(); i++){
if(--in[G[cur][i]] == 0)
q.push(G[cur][i]);
}
}
}
int main(int argc, char const **argv)
{
int from, to;
while(~scanf("%d%d", &n, &m) && (n || m)){
memset(in, 0, sizeof(in));
for(int i = 1; i <= n; i++)
G[i].clear();
for(int i = 0; i < m; i++){
scanf("%d%d", &from, &to);
in[to]++; //度
G[from].push_back(to);
}
topo();
printf("\n");
}
return 0;
}
#include
#include
#include
using namespace std;
#define maxn 5005
typedef struct { ///邻接表实现
int next_arc;///下一条边
int point;
} Arc; ///边的结构体，
Arc arc[maxn];///储存每条边
int node[maxn],vis[maxn],top[maxn];///储存每个顶点，node[i]表示第i个顶点指向的第一条边在arc中的位置
int n, m, t;
void dfs(int v) {
for (int i = node[v]; i != -1; i = arc[i].next_arc) {
if (!vis[arc[i].point]) {
dfs(arc[i].point);
}
}
vis[v] = 1;
top[--t] = v;
}
int main() {
int a, b;
while (cin >> n >> m && (m || n)) {
memset(node, -1, sizeof(node));
memset(vis, 0, sizeof(vis));
for (int i = 1; i <= m; i++) {
cin >> a >> b;
arc[i].next_arc = node[a];///第一次是出发点，以后是下一个
arc[i].point = b;
node[a] = i;
vis[arc[i].point] = 0;
}
t = n;
for (int j = 1; j <= n; j++) if (!vis[j]) dfs(j);
for (int i = 0; i < n - 1; i++)
cout << top[i] << " ";
cout << top[n - 1] << endl;
}
return 0;
}
欧拉路径和回路
首先看定义 :
欧拉回路：
(1) 图G是连通的，不能有孤立点存在。
(2) 对于无向图来说度数为奇数的点个数为0，对于有向图来说每个点的入度必须等于出度。
欧拉路径：
(1) 图G是连通的，无孤立点存在。
(2) 对于无向图来说，度数为奇数的的点可以有2个或者0个，并且这两个奇点其中一个为起点另外一个为终点。对于有向图来说，可以存在两个点，其入度不等于出度，其中一个入度比出度大1，为路径的起点；另外一个出度比入度大1，为路径的终点。
判断连通的方式有DFS或者并查集，然后再判断一下是否满足条件即可，之前做的欧拉回路的几个好题在我的github仓库
#include
const int maxn = 1000 + 5;
using namespace std;
bool vis[maxn];
int in[maxn];
int n, m;
vectorG[maxn];
void dfs(int u){
vis[u] = 1;
for(int i = 0; i < G[u].size(); i++){
if(!vis[G[u][i]])
dfs(G[u][i]);
}
}
int main(){
//freopen("in.txt","r",stdin);
int from, to;
while(scanf("%d", &n) != EOF && n){
scanf("%d", &m);
memset(vis, 0, sizeof(vis));
memset(in, false, sizeof(in));
for(int i = 1; i <= n; i++)
G[i].clear();
bool flag = true;
for(int i = 0; i < m; i++){
scanf("%d%d",&from, &to);
G[from].push_back(to);
G[to].push_back(from);
in[from]++;
in[to]++;
}
dfs(1);
for(int i = 1; i <= n; i++)
if(in[i] % 2 != 0)
flag = false;
for(int i = 1; i <= n; i++)
if(!vis[i])
flag = false;
cout << (flag ? 1 : 0) << endl;
}
return 0;
}
#include
const int maxn = 1000 + 5;
using namespace std;
int n, m, parent[maxn],ranks[maxn],in[maxn];
void init(){
for(int i = 0; i < maxn; i++)
parent[i] = i;
for(int i = 0; i < maxn; i++)
ranks[i] = 1;
}
//int findRoot(int v){
// return parent[v] == v ? v : parent[v] = findRoot(parent[v]);
//}
int findRoot(int v){
while(parent[v] != v){
parent[v] = parent[parent[v]];
v = parent[v];
}
return v;
}
void unions(int a, int b){
int aRoot = findRoot(a);
int bRoot = findRoot(b);
if (aRoot == bRoot)
return;
if (ranks[aRoot] < ranks[bRoot])
parent[aRoot] = bRoot;
else if(ranks[aRoot] > ranks[bRoot]){
parent[bRoot] = aRoot;
}else {
parent[aRoot] = bRoot;
ranks[bRoot]++;
}
}
int main(){
//freopen("in.tat","r",stdin);
int u, v;
while(scanf("%d", &n) != EOF && n){
init();
scanf("%d", &m);
memset(in,0,sizeof(in));
for(int i = 0; i < m; i++){
scanf("%d%d",&u, &v);
unions(u, v);
in[u]++;
in[v]++;
}
bool flag = true;
int temp = findRoot(1);
for(int i = 1; i <= n; i++)
if(findRoot(i) != temp)
flag = false;
for(int i = 1; i <= n; i++)
if(in[i] % 2 != 0)
flag = false; //判断度
cout << (flag ? 1 : 0) << endl;
}
return 0;
}
搜索
这里举几个比较好的题目: POJ3984，这个题目要求记录BFS最短路的路径，我这里使用三种方法:
BFS+在结构体中记录路径
BFS+记录路径
DFS加回溯法
//题目链接;http://poj.org/problem?id=3984
//题目大意：给你一个5*5的矩阵，让你找一条路，从左上点，到右下点
//解题思路:利用BFS求解最短路，利用vector记录路径
//BFS+在结构体中记录路径
#include
#include
#include
#include
#include
#include
#pragma warning(disable : 4996)
using namespace std;
const int maxn = 100 + 10;
int n;
int map[maxn][maxn];
bool vis[maxn][maxn];
int dir[4][2] = { {-1,0},{0,1},{1,0},{0,-1}};//对应上，右，下，左
struct Road {//路径记录
int x,y,d;//d表示方向
Road() {}//默认的构造函数
Road(int a,int b,int c):x(a),y(b),d(c) {}//带参数的构造函数
};
struct node {//节点类型
int x,y;
vector v;//记录路径的结构体
};
bool check(node u) {
if (!vis[u.x][u.y] && u.x >= 0 && u.x < n && u.y >= 0 && u.y < n && map[u.x][u.y] != 1)
return true;
else
return false;
}
void BFS(int x, int y) {
queueq;
node now,next;
now.x = x;
now.y = y;
now.v.push_back(Road(x,y,-1));
q.push(now);
while (!q.empty()) {
now = q.front();
q.pop();
if (now.x == n - 1 && now.y == n-1) {
for(int i = 0; i < now.v.size(); i++){
printf("(%d, %d)\n",now.v[i].x,now.v[i].y);
}
break;
}
for (int i = 0; i < 4; i++) {
next.x = now.x + dir[i][0];
next.y = now.y + dir[i][1];
if (check(next)) {
vis[next.x][next.y] = true;
next.v = now.v;
next.v[now.v.size()-1].d = i;
next.v.push_back(Road(next.x,next.y,-1));
q.push(next);
}
}
}
}
int main() {
//freopen("in.txt", "r", stdin);
flag = false;
n = 5;
memset(vis, 0, sizeof(vis));
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
scanf("%d", &map[i][j]);
}
}
BFS(0, 0);
return 0;
}
//BFS+记录路径
#include
#include
#include
using namespace std;
const int maxn = 100 + 10;
int dir[4][2] = { {-1,0},{0,1},{1,0},{0,-1}};
bool vis[maxn][maxn];
int map[maxn][maxn];
struct Node {
int x,y,pre;
};
Node m_queue[maxn];
bool Check(int x,int y){
if(!map[x][y] && !vis[x][y] && x >= 0 && x < 5&&y >= 0 && y < 5)return true;
else return false;
}
void print(int u){
if(m_queue[u].pre != -1){
print(m_queue[u].pre);
printf("(%d, %d)\n",m_queue[u].x,m_queue[u].y);
}
}
void BFS(int x,int y){
int head = 0,rear = 1;
m_queue[head].x = x;
m_queue[head].y = y;
m_queue[head].pre = -1;
vis[x][y] = true;
while(head < rear){
for(int i = 0; i < 4; i++){
int xx = m_queue[head].x + dir[i][0];
int yy = m_queue[head].y + dir[i][1];
if(Check(xx,yy)){
vis[xx][yy] = 1;
m_queue[rear].x = xx;
m_queue[rear].y = yy;
m_queue[rear].pre = head;
rear++;
}
if(xx == 4&&yy == 4)print(rear - 1);
}
head++;//出队
}
}
int main(){
//freopen("in.txt","r",stdin);
int n = 5;
memset(vis,0,sizeof(vis));
for(int i = 0; i < n; i++){
for(int j = 0; j < n; j++){
scanf("%d",&map[i][j]);
}
}
printf("(0, 0)\n");
BFS(0,0);
return 0;
}
//DFS加回溯法
#include
#include
#include
#include
#include
#include
using namespace std;
const int maxn = 100+10;
const int INF = 0x3f3f3f3f;
int n,k,ans = INF;
int map[maxn][maxn];
bool vis[maxn][maxn];
int dir[4][2] = { {-1,0},{0,1},{1,0},{0,-1}};
struct node {
int x,y;
};
vectordict;
stacks;
void memcpy(stacks){
dict.clear();
while(!s.empty()){
dict.push_back(s.top());
s.pop();
}
}
bool Check(int x,int y){
if(!vis[x][y] && map[x][y] != 1 && x >= 0 && x < n && y >= 0 && y < n)return true;
else return false;
}
void DFS(int x,int y,int step){//深刻理解递归的含义
node now;
now.x = x;
now.y = y;
s.push(now);
if(now.x == n - 1 &&now.y == n - 1){
if(step < ans){//记录最短的路径
ans = step;
memcpy(s);
}
}
for(int i = 0; i < 4; i++){
int xx = now.x + dir[i][0];
int yy = now.y + dir[i][1];
if(Check(xx,yy)){
vis[xx][yy] = true;
DFS(xx,yy,step + 1);
vis[xx][yy] = false;//回溯
}
}
s.pop();//反弹的时候重新还原栈
}
int main(){
//freopen("in.txt","r",stdin);
n = 5;
memset(vis,false,sizeof(vis));
for(int i = 0; i < n; i++){
for(int j = 0; j < n; j++){
scanf("%d",&map[i][j]);
}
}
DFS(0,0,0);
for(int i = dict.size() - 1; i >= 0; i--){
printf("(%d, %d)\n",dict[i].x,dict[i].y);
}
return 0;
}
这里再给出DFS的一个好题，印象比较深刻的
//题目链接：https://vjudge.net/contest/169966#problem/V
//题目大意: 有一个正方形的 战场看，边长为1000，西南方向在坐标原点，战场上有n 个敌人，坐标x,y,攻击范围y
//要你从西边界出发，东边界离开，求西边界和东边界上的坐标，坐标要尽量靠北，如果不能到达东边界输出IMPOSSIBLE
//解题思路: 按照 刘汝佳书上的思路，先判断有无解，从上边界开始DFS如果可以一直到达下边界，则相当于堵住了，无解
//否则，也是从上边界开始，dfs和东西边界 相连的圆(如果没有就是1000)，找到最南边的圆的 与边界相交的那个点就 0k
//主要还是DFS的运用
#include
#include
#include
#include
#include
const int maxn = 1000 + 10;
const double W = 1000.0;
using namespace std;
double x[maxn], y[maxn], r[maxn],Left,Right;
bool vis[maxn];
int n;
bool isinterect(int u, int v) {
return sqrt((x[u] - x[v])*(x[u] - x[v]) + (y[u] - y[v])*(y[u] - y[v])) <= r[u] + r[v];
}
void check_circle(int u) {
if (x[u] <= r[u])Left = min(Left, y[u] - sqrt(r[u] * r[u] - x[u] * x[u]));
if (x[u] + r[u] >= W)Right = min(Right, y[u] - sqrt(r[u] * r[u] - (W-x[u]) * (W-x[u])));
}
bool dfs(int u) {// 检查是否有解
if (vis[u] == true)return false;
vis[u] = true;
if (y[u] <= r[u])return true; //刚好碰到边界 以及 相切都可以
for (int i = 0; i < n; i++)if (isinterect(u,i) && dfs(i))return true;// if (&& dfs(i) && isinterect(u,i) )是错的，要先判断是否相交然后再dfs
check_circle(u);
return false;
}
int main() {
//freopen("in.txt", "r", stdin);
while (scanf("%d", &n) != EOF) {
memset(vis, false, sizeof(vis));
Left = Right = W;
bool flag = true;
for (int i = 0; i < n; i++) {
scanf("%lf%lf%lf", &x[i], &y[i], &r[i]);
}
for (int i = 0; i < n; i++) {
if (y[i] + r[i] >= W) { //从上往下 DFS
if (dfs(i)) { flag = false; break; }//如果能够从最上面 DFS 到最下面 则无解
}
}
if (flag) printf("0.00 %.2lf 1000.00 %.2lf\n", Left,Right);
else printf("IMPOSSIBLE\n");
}
return 0;
}
最小生成树
直接给出模板prim和kruskal(prim是堆优化的)
另外，我的另外一篇博客也总结了这两个算法。
//Prim模板
//题目链接 : http://poj.org/problem?id=1287
#include
#include
#include
#include
using namespace std;
const int maxn = 100 + 10;
const int INF = 1<<30;
struct Node{
int v,w;
Node (){}
Node (int v,int w):v(v),w(w){}
bool operator < (const Node&rhs ) const {
return rhs.w < w;
}
};
int n,d[maxn];
bool vis[maxn];
int Map[maxn][maxn];
void init(){
for(int i = 0; i < maxn; i++)vis[i] = false;
for(int i = 0; i < maxn; i++)d[i] = INF;
}
int Prim(int s){
priority_queueq;
q.push(Node(s,0));
int ans = 0;
while(!q.empty()){
Node Now = q.top(); q.pop();
int v = Now.v;
if(vis[v]) continue;
ans += Now.w;
vis[v] = true;
for(int i = 1; i <= n; i++){
int w2 = Map[v][i];
if(!vis[i] && d[i] > w2){
d[i] = w2;
q.push(Node(i,d[i]));
}
}
}
return ans;
}
int main(){
//freopen("in.txt","r",stdin);
int m,a,b,c;
while(~scanf("%d",&n)&&n){
scanf("%d",&m);
init();
for(int i = 1; i <= n; i++){
Map[i][i] = INF;
for(int j = 1; j < i; j++)Map[i][j] = Map[j][i] = INF;
}
for(int i = 0; i < m; i++){
scanf("%d%d%d",&a,&b,&c);
if(c < Map[a][b])Map[a][b] = Map[b][a] = c; //注意重边，取小的
}
printf("%d\n",Prim(1));
}
return 0;
}
//题目链接 : http://poj.org/problem?id=1287
//kruskal模板
#include
#include
#include
#include
using namespace std;
const int maxn = 1e5 + 10;
int Fa[maxn],Rank[maxn];
void init(){
for(int i = 0; i <= maxn; i++)Fa[i] = i;
for(int i = 0; i <= maxn; i++)Rank[i] = 1;
}
int Find(int v){
return Fa[v] == v ? v : Fa[v] = Find(Fa[v]);
}
void Union(int x, int y){
int fx = Find(x);
int fy = Find(y);
if (fx == fy)return;
if (Rank[fx] < Rank[fy])
Fa[fx] = fy;
else{
Fa[fy] = fx;
if (Rank[fx] == Rank[fy])Rank[fy]++;
}
}
struct Edge{
int u,v,w;
Edge(){}
Edge(int u,int v,int w):u(u),v(v),w(w){}
}edge[maxn*2];
int cmp(const void *a,const void *b){
Edge *aa = (Edge*)a;
Edge *bb = (Edge*)b;
return aa->w > bb->w ? 1 : -1; //降序
}
int krusal(int n,int m){
qsort(edge,m,sizeof(edge[0]),cmp);
int ans = 0;
int cnt = 0;
for(int i = 0; i < m; i++){
int u = edge[i].u;
int v = edge[i].v;
if(Find(u) != Find(v)){
Union(u,v);
cnt++;
ans += edge[i].w;
}
if(cnt == n-1)break;
}
return ans;
}
int main(){
//freopen("in.txt","r",stdin);
int n,m;
while(~scanf("%d",&n)&&n){
scanf("%d",&m);
init();
for(int i = 0; i < m; i++) scanf("%d%d%d",&edge[i].u,&edge[i].v,&edge[i].w); //注意这题有重边但是没事
printf("%d\n",krusal(n,m));
}
return 0;
}
最短路
dijkstra，bellman_ford，floyd，SPFA
最经典的Hdu1874畅通工程续
//堆优化dijkstra
#include
using namespace std;
const int maxn = 1e4 + 10;
const int INF = 1e9;
struct Node{
int v,w;
Node(int v,int w):v(v),w(w){}
bool operator < (const Node&rhs) const {
return rhs.w < w;
}
};
vectorG[maxn];
bool vis[maxn];
int d[maxn];
int n,m;
void init(){
for(int i = 0; i < maxn; i++)G[i].clear();
for(int i = 0; i < maxn; i++)vis[i] = false;
for(int i = 0; i < maxn; i++)d[i] = INF;
}
int dijkstra(int s,int e){ //传入起点终点
priority_queueq;
q.push(Node(s,0));
d[s] = 0;
while(!q.empty()){
Node now = q.top(); q.pop();
int v = now.v;
if(vis[v])continue;
vis[v] = true;
for(int i = 0; i < G[v].size(); i++){
int v2 = G[v][i].v;
int w = G[v][i].w;
if(!vis[v2] && d[v2] > w+d[v]){
d[v2] = w+d[v];
q.push(Node(v2,d[v2]));
}
}
}
return d[e];
}
int main(){
//freopen("in.txt","r",stdin);
int s,e;
while(~scanf("%d%d",&n,&m)){
init();
for(int i = 0; i < m; i++){
int x, y, z;
scanf("%d%d%d", &x, &y, &z);
G[x].push_back(Node(y,z));
G[y].push_back(Node(x,z));
}
scanf("%d%d",&s,&e);
int ans = dijkstra(s,e);
if(INF != ans)printf("%d\n",ans);
else printf("-1\n");
}
return 0;
}
#include
const int maxn = 1000;
#define INF 0x1f1f1f1f
using namespace std;
bool flag[maxn];
int graph[maxn][maxn],low[maxn];
void DIJ(int n, int s) {
memset(flag, false, sizeof(flag));
flag[s] = true;
for (int i = 0; i < n; i++)low[i] = graph[s][i];
for (int i = 1; i < n; i++) {
int min = INF, p;
for (int j = 0; j < n; j++)
if (!flag[j] && min > low[j]) {
min = low[j];
p = j;
}
flag[p] = true;
for (int j = 0; j < n; j++)
if (!flag[j] && low[j] > graph[p][j] + low[p])
low[j] = graph[p][j] + low[p];
}
}
int main() {
int n, m, begin, t;
while (~scanf("%d%d",&n,&m)) {
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
if (i == j)
graph[i][j] = 0;
else
graph[i][j] = INF;
for (int i = 1; i <= m; i++) {
int x, y, z;
scanf("%d%d%d", &x, &y, &z);
if (z < graph[x][y]) graph[x][y] = graph[y][x] = z;
}
cin >> begin >> t;
DIJ(n, begin);
if (low[t] < INF) cout << low[t] << endl;
else cout << "-1" << endl;
}
return 0;
}
#include
#define INF 0x1f1f1f1f
using namespace std;
const int maxn = 1000;
vector >Edge[maxn];
int n, m, dist[maxn];
void init() {
for (int i = 0; i < maxn; i++)Edge[i].clear();
for (int i = 0; i < maxn; i++)dist[i] = INF;
}
int main() {
int s, t;
while (cin >> n >> m) {
init();
for (int i = 0; i < m; i++) {
int x, y, z;
cin >> x >> y >> z;
Edge[x].push_back(make_pair(y, z));
Edge[y].push_back(make_pair(x, z));
}
cin >> s >> t;
priority_queue>q;
dist[s] = 0;
q.push(make_pair(-dist[s], s));
while (!q.empty()) {
int now = q.top().second;
q.pop();
for (int i = 0; i < Edge[now].size(); i++) {
int v = Edge[now][i].first;
if (dist[v] > dist[now] + Edge[now][i].second) {
dist[v] = dist[now] + Edge[now][i].second;
q.push(make_pair(-dist[v], v));
}
}
}
if (dist[t] < INF)cout << dist[t] << endl;
else cout << "-1" << endl;
}
return 0;
}
//(3)bellman_ford
#include
#define maxn 1000
#define INF 0x1f1f1f1f
using namespace std;
struct Edge {
int u, v;
int weight;
};
Edge edge[maxn * 2];
int dist[maxn];
void bellman_ford(int s, int n, int m) {
for (int i = 0; i < n; i++) dist[i] = INF;
dist[s] = 0;
for (int i = 0; i < n; i++)
for (int j = 0; j < 2 * m; j++)
if (dist[edge[j].u] > dist[edge[j].v] + edge[j].weight)
dist[edge[j].u] = dist[edge[j].v] + edge[j].weight;
}
int main() {
int n, m, s, t;
while (cin >> n >> m) {
for (int i = 0; i < m; i++) {
scanf("%d%d%d", &edge[i].u, &edge[i].v, &edge[i].weight);
edge[i + m].v = edge[i].u;
edge[i + m].u = edge[i].v;
edge[i + m].weight = edge[i].weight;
}
cin >> s >> t;
bellman_ford(s, n, m);
if (dist[t] < INF) cout << dist[t] << endl;
else cout << "-1" << endl;
}
return 0;
}
//(4)floyd
#include
#define maxn 1000
#define INF 0x1f1f1f1f
using namespace std;
int graph[maxn][maxn];
int low[maxn];
void floyd(int n) {
for (int k = 0; k < n; k++)
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
graph[i][j] = min(graph[i][j], graph[i][k] + graph[k][j]);
}
int main() {
int n, m, s, t;
while (cin >> n >> m) {
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
if (i == j)
graph[i][j] = 0;
else
graph[i][j] = INF;
for (int i = 1; i <= m; i++) {
int x, y, z;
scanf("%d%d%d", &x, &y, &z);
if (graph[x][y] > z) graph[x][y] = graph[y][x] = z;
}
floyd(n);
scanf("%d%d", &s, &t);
if (graph[s][t] < INF) cout << graph[s][t] << endl;
else cout << "-1" << endl;
}
return 0;
}
//(5)SPFA
#include
#define maxn 1000
#define INF 0x1f1f1f1f
using namespace std;
int graph[maxn][maxn],flag[maxn],dist[maxn];
void SPFA(int s, int n) {
queueq;
memset(flag, false, sizeof(flag));
for (int i = 0; i < n; i++) dist[i] = INF;
q.push(s);
dist[s] = 0;
flag[s] = true;
while (!q.empty()) {
int temp = q.front();
q.pop();
flag[temp] = false;
for (int i = 0; i < n; i++) {
if (dist[i] > dist[temp] + graph[temp][i]) {
dist[i] = dist[temp] + graph[temp][i];
if (!flag[i]) {
q.push(i);
flag[i] = true;
}
}
}
}
}
int main() {
int n, m, s, t;
while (cin >> n >> m) {
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
if (i == j)
graph[i][j] = 0;
else
graph[i][j] = INF;
for (int i = 0; i < m; i++) {
int x, y, z;
cin >> x >> y >> z;
if (z < graph[x][y]) graph[x][y] = graph[y][x] = z;
}
cin >> s >> t;
SPFA(s, n);
if (dist[t] < INF) cout << dist[t] << endl;
else cout << "-1" << endl;
}
return 0;
}
//(6)pair+SPFA
#include
#define INF 0x1f1f1f1f
using namespace std;
const int maxn = 1000;
vector >Edge[maxn];
int n, m,dist[maxn];
bool flag[maxn];
void init() {
for (int i = 0; i < maxn; i++)Edge[i].clear();
for (int i = 0; i < maxn; i++)flag[i] = false;
for (int i = 0; i < maxn; i++)dist[i] = INF;
}
int main() {
int s, t;
while (cin >> n >> m) {
init();
for (int i = 0; i < m; i++) {
int x, y, z;
cin >> x >> y >> z;
Edge[x].push_back(make_pair(y, z));
Edge[y].push_back(make_pair(x, z));
}
cin >> s >> t;
queueq;
dist[s] = 0;
flag[s] = true;
q.push(s);
while (!q.empty()) {
int now = q.front();
q.pop();
flag[now] = false;
for (int i = 0; i < Edge[now].size(); i++) {
int v = Edge[now][i].first;
if (dist[v] > dist[now] + Edge[now][i].second) {
dist[v] = dist[now] + Edge[now][i].second;
if (!flag[Edge[now][i].first]) {
q.push(Edge[now][i].first);
flag[Edge[now][i].first] = true;
}
}
}
}
if (dist[t] < INF)cout << dist[t] << endl;
else cout << "-1" << endl;
}
return 0;
}
这里给出一个比较特殊的最短路题目
1.最短路的条数
2.多条时选择消防员(最短路经过的点的那些权值)多的那一条
3.记录路径
#include
using namespace std;
const int maxn = 1e4 + 10;
const int INF = 1e9;
typedef long long LL;
struct Node{
int v,w;
Node(int v,int w):v(v),w(w){}
bool operator < (const Node&rhs) const {
return rhs.w < w;
}
};
vectorG[maxn];
bool vis[maxn];
int Pa[maxn],Weight[maxn],TotalWeight[maxn],TotalRoad[maxn];
int d[maxn];
int n,m,s,e;
void init(){
for(int i = 0; i < maxn; i++)G[i].clear();
for(int i = 0; i < maxn; i++)vis[i] = false;
for(int i = 0; i < maxn; i++)d[i] = INF;
for(int i = 0; i < maxn; i++)Pa[i] = -1; //记录路径
for(int i = 0; i < maxn; i++)TotalRoad[i] = 0;
for(int i = 0; i < maxn; i++)TotalWeight[i] = 0;
}
void PrintPath(int x){
if(Pa[x] == -1) printf("%d",x);
else {
PrintPath(Pa[x]);
printf(" %d",x);
}
}
int dijkstra(int s,int e){ //传入起点终点
priority_queueq;
q.push(Node(s,0));
d[s] = 0, Pa[s] = -1, TotalWeight[s] = Weight[s],TotalRoad[s] = 1;
while(!q.empty()){
Node now = q.top(); q.pop();
int v = now.v;
if(vis[v])continue;
vis[v] = true;
for(int i = 0; i < G[v].size(); i++){
int v2 = G[v][i].v;
int w = G[v][i].w;
if(!vis[v2] && d[v2] > w+d[v]){
d[v2] = w + d[v];
TotalWeight[v2] = TotalWeight[v] + Weight[v2];
Pa[v2] = v;
TotalRoad[v2] = TotalRoad[v];
q.push(Node(v2,d[v2]));
}
else if(!vis[v2] && d[v2] == w+d[v]){
if(TotalWeight[v2] < TotalWeight[v] + Weight[v2]){ //如果消防员个数更多
TotalWeight[v2] = TotalWeight[v] + Weight[v2];
Pa[v2] = v;
//q.push(Node(v2,d[v2]));不需要入队了
}
TotalRoad[v2] += TotalRoad[v]; //加上之前的条数
}
}
}
return d[e];
}
int main(){
//freopen("in.txt","r",stdin);
int a,b,c;
scanf("%d%d%d%d",&n,&m,&s,&e);
for(int i = 0; i < n; i++)scanf("%d",&Weight[i]);
init();
for(int i = 0; i < m; i++){
scanf("%d%d%d",&a,&b,&c);
G[a].push_back(Node(b,c));
G[b].push_back(Node(a,c));
}
int ans = dijkstra(s,e);
//if(INF != ans)printf("%d\n",ans); else printf("-1\n");
printf("%d %d\n",TotalRoad[e],TotalWeight[e]);
PrintPath(e);
printf("\n");
return 0;
}
GCD和LCM
注意一下n个数的GCD和LCM
//题目连接 : http://acm.hdu.edu.cn/showproblem.php?pid=1019
#include
using namespace std;
const int maxn = 100 + 10;
int gcd(int a,int b){
return b == 0?a:gcd(b,a%b);
}
int lcm(int a,int b){
return a/gcd(a,b)*b;
}
int ngcd(int v[],int n){
if(n == 1) return v[0];
return gcd(v[n-1],ngcd(v,n-1));
}
int nlcm(int v[],int n){
if(n == 1) return v[0];
return lcm(v[n-1],nlcm(v,n-1));
}
int main(){
int n,m,a[maxn];
scanf("%d",&n);
while(n--){
scanf("%d",&m);
for(int i = 0; i < m; i++)scanf("%d",&a[i]);
//printf("%d\n",ngcd(a,m));
printf("%d\n",nlcm(a,m));
}
return 0;
}
埃拉托斯特尼筛法
素数和分解定理等看另一篇博客总结。
比较经典的快速筛素数，给个例题，用BFS和筛素数解决
#include
#include
#include
using namespace std;
const int maxn = 10000 + 10;
int prime[maxn],s,e,vis[maxn];
bool is_prime[maxn],flag;
//素数筛选的模板 : |埃式筛法|
int Sieve(int n) {
int k = 0;
for(int i = 0; i <= n; i++)is_prime[i] = true;
is_prime[0] = false,is_prime[1] = false;
for(int i = 2; i <= n; i++) {
if(is_prime[i]) {
prime[k++] = i;
for(int j = i*i; j <= n; j += i)is_prime[j] = false; // 轻剪枝，j必定是i的倍数
}
}
return k;
}
struct Node {
int v,step;
Node(){}
Node(int v,int step):v(v),step(step){}
};
void cut(int n,int *a){ //将各位存到a数组中
int index = 3;
while(n > 0){
a[index--] = n%10;
n /= 10;
}
}
int rev(int *a){ //还原
int s = 0;
for(int i = 0; i < 4; i++)s = s*10 + a[i];
return s;
}
void BFS(int s,int step) {
queueq;
Node now,next;
q.push(Node(s,step));
vis[s] = 1;
while(!q.empty()) {
now = q.front();q.pop();
if(now.v == e) {
flag = true;
printf("%d\n",now.step);
return ;
}
int a[4],b[4];
cut(now.v,a);
for(int i = 0; i < 4; i++){
memcpy(b,a,sizeof(b));
for(int j = 0; j <= 9; j++){
b[i] = j;
next.v = rev(b);
if(next.v < 10000 && next.v > 1000 && is_prime[next.v] && !vis[next.v] && (next.v != now.v)) {
vis[next.v] = 1;
next.step = now.step+1;
q.push(next);
}
}
}
}
}
int main() {
int T;
Sieve(maxn); //先把素数筛选出来
scanf("%d",&T);
while(T--) {
flag = false;
memset(vis,0,sizeof(vis));
scanf("%d%d",&s,&e);
BFS(s,0);
if(flag == 0)printf("Impossible\n");
}
return 0;
}
唯一分定理
具体的不细说，看一个比较简单的模板题其余还有题目在我的代码仓库。
//题目连接 : https://acm.sdut.edu.cn/onlinejudge2/index.php/Home/Index/problemdetail/pid/1634.html
#include
using namespace std;
const int maxn = 30000;
int prime[maxn];
bool is_prime[maxn];
//素数筛选的模板 : |埃式筛法|
int Sieve(int n) {
int k = 0;
for(int i = 0; i <= n; i++)is_prime[i] = true;
is_prime[0] = false,is_prime[1] = false;
for(int i = 2; i <= n; i++) {
if(is_prime[i]) {
prime[k++] = i;
for(int j = i*i; j <= n; j += i)is_prime[j] = false; // 轻剪枝，j必定是i的倍数
}
}
return k;
}
int main(){
int T,n;
scanf("%d",&T);
int len = Sieve(maxn);
while(T--){
scanf("%d",&n);
int ans[maxn],k = 0;
for(int i = 0; i < len; i++){ //唯一分解定理
while(n % prime[i] == 0){
ans[k++] = prime[i];
n /= prime[i];
}
}
for(int i = 0; i < k; i++)printf(i == 0 ? "%d": "*%d",ans[i]);
printf("\n");
}
return 0;
}
扩展欧几里得
基本算法：对于不完全为 0的非负整数 a，b，gcd(a，b)表示a，b的最大公约数，必然存在整数对x，y，使得 gcd(a，b)=ax+by。，具体用处在于:
求解不定方程；
求解模线性方程(线性同余方程)；
求解模的逆元；
给出一个讲的不错的博客。
这里给出一个求解不定方程组解的测试程序：
//扩展欧几里得的学习
#include
int exgcd(int a,int b,int &x,int &y){
if(b == 0){
x = 1;
y = 0;
return a;
}
int d = exgcd(b,a%b,x,y); //d 就是gcd(a,b)
int t = x;
x = y;
y = t-(a/b)*y;
return d;
}
bool linear_equation(int a,int b,int c,int &x,int &y){
int d = exgcd(a,b,x,y); //d是gcd(a,b)//求出a*x+b*y = gcd(a,b)的一组解
printf("%d*x + %d*y = %d(gcd(a,b))的一些解是\n",a,b,d);
printf("%d %d\n",x,y); //第一组
for(int t = 2; t < 10; t++){ //输出 a*x + b*y = gcd(a,b)的其他一些解
int x1 = x + b/d*t;
int y1 = y - a/d*t;
printf("%d %d\n",x1,y1); //其余组
}
printf("\n\n"); //第一组
if(c%d) return false;
int k = c/d; //上述解乘以 c/gcd(a,b)就是 a*x +b*y = c的解
x *= k; y *= k; //求得的只是其中一组解
return true;
}
int main(){
//freopen("in.txt","r",stdin)；
int a = 6,b = 15,c = 9; //求解 6*x + 15*y = 9的解
int x,y;
int d = exgcd(a,b,x,y);
if(!linear_equation(a,b,c,x,y))printf("无解\n");
printf("%d*x + %d*y = %d的一些解是\n",a,b,c);
printf("%d %d\n",x,y); //第一组
for(int t = 2; t < 10; t++){ //输出其他的一些解
int x1 = x + b/d*t;
int y1 = y - a/d*t;
printf("%d %d\n",x1,y1); //其余组
}
return 0;
}
再给出一个比较简单的模板题
//题目链接：http://poj.org/problem?id=1061
//题目大意：中文题，给出青蛙A，B的起点坐标,以及跳跃距离m,n以及环的长度L，求什么时候能相遇
/*解题思路： 假设跳了T次以后，青蛙1的坐标便是x+m*T,青蛙2的坐标为y+n*T。它们能够相遇的情况为(x+m*T)-(y+n*T)==P*L，其中P为某一个整数，变形一下设经过T次跳跃相遇,得到(n-m)*T-P*L==x-y 我们设a=(n-m),b=L,c=x-y,T=x,P=y.
得到ax+by==c，直接利用欧几里得扩展定理可以得到一组x,y但是这组x,y不一定是符合条件的最优解，
首先,当gcd(a,b)不能整除c的时候是无解的，当c能整除gcd(a,b)时，把x和y都要变为原来的c/gcd(a,b)倍，
我们知道它的通解为x0+b/gcd(a,b)*t要保证这个解是不小于零的最小的数，
我们先计算当x0+b/gcd(a,b)*t=0时的t值，
此时的t记为t0=-x0/b/gcd(a,b)(整数除法)，代入t0如果得到的x小于零再加上一个b/gcd(a,b)就可以了*/
#include
using namespace std;
typedef long long LL;
LL exgcd(LL a,LL b,LL &x,LL &y){
if(b == 0){
x = 1;
y = 0;
return a;
}
LL d = exgcd(b,a%b,x,y);
LL t = x;
x = y;
y = t-(a/b)*y;
return d;
}
int main(){
//freopen("in.txt","r",stdin);
LL x,y,m,n,L,T,P;
while(cin>>x>>y>>m>>n>>L){
LL a,b,c;
a = n-m;
b = L;
c = x-y;
LL d = exgcd(a,b,T,P);
if(c%d!=0){ cout<
T = T*(c/d);
P = P*(c/d);
LL k = T*d/b;
k = T-k*b/d;
if(k < 0) k = k+b/d;
printf("%lld\n",k);
}
return 0;
}
欧拉函数
欧拉函数只是工具：
提供1到N中与N互质的数；
对于一个正整数N的素数幂分解为N = P1^q1 * P2^q2 * ... * Pn^qn，则欧拉函数 γ(N) = N*(1-1/P1) * (1-1/P2) * ... * (1-1/Pn)。
这里也给出一个博客讲解。
//欧拉函数模板
//题目连接 : https://vjudge.net/contest/185827#problem/G
//题目意思 : 就是要你求1~n互素的对数(注意1~1不要重复)
#include
#include
const int maxn = 50000;
int phi[maxn+1], phi_psum[maxn+1];
int euler_phi(int n){
int m = sqrt(n+0.5);
int ans = n;
for(int i = 2; i < m; i++)if(n % i == 0){
ans = ans/i*(i-1);
while(n % i == 0)n /= i;
}
if(n > 1)ans = ans/n*(n-1);
return ans;
}
//筛素数的方法,求解1~n所有数的欧拉phi函数值
void phi_table(int n) {
phi[1] = 0; //这里不计算第一个1,1和1,1是重复的，等下直接2*phi_psum[n] + 1
for(int i = 2; i <= n; i++) if(phi[i] == 0)
for(int j = i; j <= n; j += i) {
if(phi[j] == 0) phi[j] = j;
phi[j] = phi[j] / i * (i-1);
}
}
int main() {
int n;
phi_table(maxn);
phi_psum[0] = 0;
for(int i = 1; i <= maxn; i++)phi_psum[i] = phi_psum[i-1] + phi[i];
while(scanf("%d", &n) == 1 && n) printf("%d\n",2*phi_psum[n] + 1);
return 0;
}
这里再贴上大牛的模板：
const int MAXN = 10000000;
bool check[MAXN+10];
int phi[MAXN+10];
int prime[MAXN+10];
int tot;//素数的个数
// 线性筛(同时得到欧拉函数和素表)
void phi_and_prime_table(int N) {
memset(check,false,sizeof(check));
phi[1] = 1;
tot = 0;
for(int i = 2; i <= N; i++) {
if( !check[i] ) {
prime[tot++] = i;
phi[i] = i-1;
}
for(int j = 0; j < tot; j++) {
if(i * prime[j] > N)break;
check[i * prime[j]] = true;
if( i % prime[j] == 0) {
phi[i * prime[j]] = phi[i] * prime[j];
break;
} else {
phi[i * prime[j]] = phi[i] * (prime[j] - 1);
}
}
}
}
快速幂
乘法快速幂看这里。
#include
//计算(a*b)%c
long long mul(long long a,long long b,long long mod) {
long long res = 0;
while(b > 0){
if( (b&1) != 0) // 二进制最低位是1 --> 加上 a的 2^i 倍, 快速幂是乘上a的2^i )
res = ( res + a) % mod;
a = (a << 1) % mod; // a = a * 2 a随着b中二进制位数而扩大 每次 扩大两倍。
b >>= 1; // b -> b/2 右移 去掉最后一位 因为当前最后一位我们用完了，
}
return res;
}
//幂取模函数
long long pow1(long long a,long long n,long long mod){
long long res = 1;
while(n > 0){
if(n&1)
res = (res * a)%mod;
a = (a * a)%mod;
n >>= 1;
}
return res;
}
// 计算 ret = (a^n)%mod
long long pow2(long long a,long long n,long long mod) {
long long res = 1;
while(n > 0) {
if(n & 1)
res = mul(res,a,mod);
a = mul(a,a,mod);
n >>= 1;
}
return res;
}
//递归分治法求解
int pow3(int a,int n,int Mod){
if(n == 0)
return 1;
int halfRes = pow1(a,n/2,Mod);
long long res = (long long)halfRes * halfRes % Mod;
if(n&1)
res = res * a % Mod;
return (int)res;
}
int main(){
printf("%lld\n",mul(3,4,10));
printf("%lld\n",pow1(2,5,3));
printf("%lld\n",pow2(2,5,3));
printf("%d\n",pow3(2,5,3));
return 0;
}
矩阵快速幂
这个也是比较常用的，主要还是在于常数矩阵的求解和递推公式的求解，这里给出一个博客讲解和自己写过的一道模板题，以及后面自己的总结。
转换之后，直接把问题转化为求矩阵的n-9次幂。
//题目链接：https://vjudge.net/contest/172365#problem/A
//题目大意：函数满足——If x < N f(x) = x.
//If x >= N f(x) = a0 * f(x - 1) + a1 * f(x - 2) + a2 * f(x - 3) + …… + a9 * f(x - N);
//ai(0<=i<=9) can only be 0 or 1 .
//要求f(k) % mod;
//解题思路：构造矩阵求解N*N矩阵
#include
#include
const int N = 10;
using namespace std;
int Mod;
struct Matrix {
int m[N][N];
Matrix(){}
};
void Init(Matrix &matrix){
for(int i = 0;i < N; i++)scanf("%d",&matrix.m[0][i]);
for(int i = 1;i < N; i++){
for(int j = 0;j < N; j++){
if(i == (j+1))matrix.m[i][j] = 1;
else matrix.m[i][j] = 0;
}
}
}
//矩阵相乘
Matrix Mul(Matrix &a,Matrix &b){
Matrix c;
for(int i = 0; i < N; i++){
for(int j = 0;j < N; j++){
c.m[i][j] = 0;
for(int k = 0; k < N; k++)c.m[i][j] += a.m[i][k]*b.m[k][j];
c.m[i][j] %= Mod;
}
}
return c;
}
//矩阵幂
Matrix Pow(Matrix& matrix, int k) {
Matrix res;
for (int i = 0; i < N; ++i)
for (int j = 0; j < N; ++j)
if (i == j) res.m[i][j] = 1;
else res.m[i][j] = 0;
while (k) {
if (k & 1) res = Mul(matrix,res);
k >>= 1;
matrix = Mul(matrix,matrix);
}
return res;
}
int main() {
int k,a[N];
while (~scanf("%d%d",&k,&Mod)) {
Matrix matrix;
Init(matrix);
if (k < 10) { printf("%d\n",k % Mod); continue; }
matrix = Pow(matrix,k-9);
int sum = 0;
for (int i = 0; i < N; i++)sum += matrix.m[0][i] * (9 - i) % Mod;
printf("%d\n",sum%Mod);
}
return 0;
}