算法刷题记录(Day 2)

容易遗忘的一些点

1. scanf返回值为成功读取的元素的数目
2. long long的格式化字符串为%lld

偶数矩阵*（Uva11464 P14）

题目类型:可计算性枚举
看到这题首先是有点懵的，匹配不到算法让我慌张，事实证明暴力枚举是一种较好的方法，但是枚举也是需要一些优化思路的，比如这道题目。如果对所有的情况都进行枚举，则有2²⁵⁵种，而我们需要抓住枚举+可计算性，来将枚举的次数降低到2¹⁵，从而达到较好的效果。
思路点：

1. 以二进制的方式进行枚举可以从0开始再到2^k-1(k为位数)
2. 注意！！！是1<<k而不是2<<k

#include<iostream>
using namespace std;
#define NMAX 20
int T, n;
int A[NMAX][NMAX], B[NMAX][NMAX];
void past(int x) { //用来填充第一行
	for (int i = n - 1;i >= 0;i--) {
		B[0][i] = x % 2;
		x = x >> 1;
	}
}
int ca(void) { //根据第一行进行下面几行的计算，并记录改变的次数，若出现1变为0的情况，则直接退出并返回最大值
	int res = 0;
	for (int i = 0;i < n;i++) {
		if (B[0][i] != A[0][i]) res++;
	}
	for (int i = 1;i < n;i++) {
		for (int j = 0;j < n;j++) {
			int cur = 0;
			if (i - 1 >= 0 && j - 1 >= 0) cur += B[i - 1][j - 1];
			if (i - 2 >= 0) cur += B[i - 2][j];
			if (i - 1 >= 0 && j + 1 < n) cur += B[i - 1][j + 1];
			B[i][j] = cur % 2;
			if (B[i][j] != A[i][j]) res++;
			if (B[i][j] == 0 && A[i][j] == 1) {
				res = n * n + 1;
				goto ret;
			}
		}
	}
	ret:
	return res;
}
int main() {
	cin >> T;
	while (T--) {
		cin >> n;
	
		for (int i = 0;i < n;i++) {
			for (int j = 0;j < n;j++) cin >> A[i][j];
		}
		int res = n*n+1;
		for (int i = 0;i < (1 << n);i++) {
			past(i);
			int cur = ca();
			res = min(res, cur);
			/*cout << i << "---------------------------- " << endl;
			for (int u = 0;u < n;u++) {
				for (int v = 0;v < n;v++) cout << B[u][v] << " ";
				cout << endl;
			}
			cout << cur << "------------------------------" << endl << endl;*/
		}
		cout << res << endl;
	}
}

计算器谜题*（Uva11549 P39）

题目类型:模拟

根据题目的提示发现一定会存在一个循环，当出现一个重复的数的时候就可以停止计算，并给出最终的最大值的结果。
那么如何判断循环?

1. 使用数组记录已经计算出的值，再在数组中进行查找。进一步地，可以使用STL中的set进行优化，使用count函数进行是否已经存在的验证。
   set的使用

2. 使用Floyd判圈算法，k1为乘一次的结果，k2为乘两次的结果，当他们相等的时候，则代表循环早已出现，此时退出。（是否存在循环判断的滞后问题呢 ？） 可以降低空间复杂度
   Floyd判圈算法

那么如何计算并取前n位?

1. 利用除法，但是首先需要得到结果的位数，因此稍显繁琐。
2. 首先将各位分离并存放在数组中，然后再取前n位进行一个总和
3. 利用sstream实现string类型到long long的转化，进而利用string.substr(0,n)获取前n位的情况

string stream

stringstream stream;
stream<<t;//向流中传值
out_type result;//这里存储转换结果
stream>>result;//向result中写入值
return result;

The Embarrassed Cryptographer(poj 2365)

原题链接
题目类型:分解因子
rho快速因数分解算法
辗转相除法

#include<iostream>
#include<algorithm>
using namespace std;
typedef long long ll;

ll K, T;
ll f(ll x,ll n) {
    int u = rand();
    return (x*x + u) % n;
}

ll gcd(ll x, ll y)
{
    ll r;
    ll a = x, b = y;
    while (a % b != 0)
    {
        r = a % b;
        a = b;
        b = r;
    }
    return b;
}

ll rho(ll n) {
    ll a = 0;
    ll b = 1;
    ll p = 0;
    while (1) {
        a = b = rand() % n + 1;
        p = 0;
        while (1) {
            a = f(a,n);
            b = f(f(b,n),n);
            if (a == b)break; //利用Floyd判环算法来实现对于该随机数下的尽快退出
            ll ui = abs(b - a); //利用两个之间的差值来生成待测试的ui,使用的是步长
            ll tt = gcd(ui, n);
            if (tt == 1 || tt == n)continue;
            if (tt > 1) {
                p = tt;
                break;
            }
        }
        if (p)break;
    }
    return p;
}
int main() {
    while (1) {
        cin >> K >> T;
        if (K == 0 && T == 0) break;
        ll f1, f2, res;
        f1 = rho(K);
        f2 = K / f1;
        res = min(f1, f2);
        if (res < T) printf("BAD %lld\n", res);
        else printf("GOOD\n");
    }
}

后续分析:
1.K的范围已经超过了long long，因此需要使用千进制进行存储

参考题解:
素数线性筛法
题解
大致思路为:首先使用素数线性筛法获取小于l的所有素数。对于大数K，使用千进制进行存储，利用同余的性质，逐3位求出K对于prime[i]的模数。若为0，则代表存在一个小于l的素因子，输出No,否则输出GOOD

//引用自题解的代码
#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;
#define maxn 1111111
int mark[maxn],prime[maxn],res;//prime存储素数,从0开始,mark[i]表示i的最小素因数 
void get_prime()//素数线性筛法,得到n以内所有素数共res个 
{
    memset(mark,0,sizeof(mark));
    res=0;
    for(int i=2;i<maxn;i++)
    {
        if(!mark[i]) 
            mark[i]=prime[res++]=i;
        for(int j=0;j<res&&prime[j]*i<maxn;j++)
        {
            mark[i*prime[j]]=prime[j];
            if(i%prime[j]==0) 
                break;
        }
    }
} 
int main()
{
    get_prime();
    char s[111];
    int k[33],l,n;
    while(~scanf("%s%d",s,&l),s[0]!='0'&&l)
    {
        n=0;
        int i=strlen(s)-1,j,temp,mul,flag=1;
        while(i>=0)
        {
            j=0,temp=0,mul=1;
            while(j<3&&i>=0)
            {
                temp=temp+(s[i]-'0')*mul;
                i--,j++,mul*=10;
            }
            k[n++]=temp;
        }
        i=0;
        while(prime[i]<l)
        {
            temp=0;
            for(j=n-1;j>=0;j--)
                temp=(temp*1000+k[j])%prime[i];
            if(!temp)
            {
                flag=0;
                printf("BAD %d\n",prime[i]);
                break;
            }
            i++;
        }
        if(flag)printf("GOOD\n");
    }
    return 0;
}

总结

路漫漫其修远兮，明天得提高效率了。