SRM 620
easy：
两个数要向上还原一步的话，肯定是大减小。然后两组数谁比较大，谁就向上还原一步。
medium：
我们试想最后一次排序是什么样，就是和最终序列大小关系必须满足，但是有些相等的我们并不能保证可以排成最后的样子。
那么倒数第二次排序呢？即最后一次排序的那些可以保证关系我们可以不用管，其他的关系必须满足。。。
这样我们就能一直划分成一段一段。。。最后每个数单独一段就是possible
因为我们不知道几次可以完成，我们迭代超过m次，再接着迭代肯定是无用的。
（讲不太清楚，我把代码贴上来，flag[i]表示i与i+1有没有被隔开
代码：
#include <vector>
#include <list>
#include <map>
#include <set>
#include <deque>
#include <stack>
#include <bitset>
#include <algorithm>
#include <functional>
#include <numeric>
#include <utility>
#include <sstream>
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <ctime>
#include <cstring>
using namespace std;
class CandidatesSelection {
public:
string possible(vector<string> , vector<int> );
};
bool flag[55];
string CandidatesSelection::possible(vector<string> score, vector<int> result) {
int i, j, k, n, m;
n = score.size();
m = score[0].size();
memset(flag, 0, sizeof(flag));
for (j = 0; j < m + 2; ++j) {
for (k = 0; k < m; ++k) {
bool f = true;
for (i = 0; i < n - 1; ++i) {
if (flag[i])
continue;
if (score[result[i]][k] > score[result[i + 1]][k]) {
f = false;
break;
}
}
if (f == false)
continue;
for (i = 0; i < n - 1; ++i) {
if (flag[i])
continue;
if (score[result[i]][k] < score[result[i + 1]][k]) {
flag[i] = true;
}
}
}
}
bool f = true;
for (i = 0; i < n - 1; ++i) {
if (flag[i])
continue;
if (result[i] < result[i + 1]) {
flag[i] = true;
}
if (flag[i] == false)
f = false;
}
if (f)
return "Possible";
else
return "Impossible";
}
hard：
看到counting，我刚开始以为是dp。。。其实是个高斯消元。。。
首先对于每个素数，如果一个数它包含这个素数奇数次，那么这种数必须出现偶数次
这样可以对于每个素数列一个方程
然后对于每一行每一列，再列一个方程
然后解出这个方程的自由元个数，2^自由元个数 就是答案。
代码：
#include <vector>
#include <list>
#include <map>
#include <set>
#include <deque>
#include <stack>
#include <bitset>
#include <algorithm>
#include <functional>
#include <numeric>
#include <utility>
#include <sstream>
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <ctime>
#include <cstring>
using namespace std;
class PerfectSquare {
public:
int ways(vector<int> );
};
const int maxn = 10005;
int a[maxn][450], y[maxn];
int Gauss(int x[maxn], int n, int m) {
int i, j, k;
int now;
now = 0;
for (i = 0; i < n; ++i) {
for (j = now; j < m; ++j) {
if (a[j][i] == 1) {
if (j == now)
break;
for (k = 0; k <= n; ++k)
a[now][k] ^= a[j][k];
break;
}
}
if (j == m)
continue;
for (j = now + 1; j < m; ++j) {
if (a[j][i] == 0)
continue;
for (k = 0; k <= n; ++k)
a[j][k] ^= a[now][k];
}
now++;
}
for (j = now; j < m; ++j)
if (a[j][n] == 1)
return -1;
return n - now;
}
map<int, int> m;
int ed;
vector<int> v[100000];
int PerfectSquare::ways(vector<int> x) {
int n, i, j, k, p;
n = x.size();
m.clear();
ed = 1;
for (i = 0; i < n; ++i) {
int j = x[i];
for (k = 2; k * k <= j; ++k) {
if (j % k == 0) {
int cnt = 0;
while (j % k == 0) {
cnt++;
j /= k;
}
if (cnt % 2) {
p = m[k];
if (p == 0) {
p = ed;
m[k] = ed++;
v[p].clear();
}
v[p].push_back(i);
}
}
}
if (j != 1) {
p = m[j];
if (p == 0) {
p = ed;
m[j] = ed++;
v[p].clear();
}
v[p].push_back(i);
}
}
memset(a, 0, sizeof(a));
for (j = 1; j < ed; ++j) {
for (k = 0; k < v[j].size(); ++k) {
a[j - 1][v[j][k]] = 1;
}
a[j - 1][n] = 0;
}
int nn = sqrt((double) n);
for (i = 0; i < nn; ++i) {
for (j = 0; j < nn; ++j) {
a[ed - 1][i * nn + j] = 1;
}
a[ed - 1][n] = 1;
ed++;
}
for (j = 0; j < nn; ++j) {
for (i = 0; i < nn; ++i) {
a[ed - 1][i * nn + j] = 1;
}
a[ed - 1][n] = 1;
ed++;
}
int ans = Gauss(y, n, ed - 1);
if (ans < 0)
return 0;
int pmod = 1000000007;
int aans = 1;
for (i = 0; i < ans; ++i)
aans = aans * 2 % pmod;
return aans;
}