容易遗忘的一些点
- scanf返回值为成功读取的元素的数目
- long long的格式化字符串为%lld
偶数矩阵*(Uva11464 P14)
题目类型:可计算性枚举
看到这题首先是有点懵的,匹配不到算法让我慌张,事实证明暴力枚举是一种较好的方法,但是枚举也是需要一些优化思路的,比如这道题目。如果对所有的情况都进行枚举,则有2255种,而我们需要抓住枚举+可计算性,来将枚举的次数降低到215,从而达到较好的效果。
思路点:
- 以二进制的方式进行枚举可以从0开始再到2^k-1(k为位数)
- 注意!!!是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)
题目类型:模拟
根据题目的提示发现一定会存在一个循环,当出现一个重复的数的时候就可以停止计算,并给出最终的最大值的结果。
那么如何判断循环?
-
使用数组记录已经计算出的值,再在数组中进行查找。进一步地,可以使用STL中的set进行优化,使用count函数进行是否已经存在的验证。
set的使用 -
使用Floyd判圈算法,k1为乘一次的结果,k2为乘两次的结果,当他们相等的时候,则代表循环早已出现,此时退出。
(是否存在循环判断的滞后问题呢 ?)可以降低空间复杂度
Floyd判圈算法
那么如何计算并取前n位?
- 利用除法,但是首先需要得到结果的位数,因此稍显繁琐。
- 首先将各位分离并存放在数组中,然后再取前n位进行一个总和
- 利用sstream实现string类型到long long的转化,进而利用string.substr(0,n)获取前n位的情况
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;
}
总结
路漫漫其修远兮,明天得提高效率了。