H. Combination Lock（二分图博弈）
这个当时想了很久没什么想法，没想到是一道模板题
在一个二分图上，在某个点开始，两个人轮流选边到另一个点
选过的点不能再选。谁无法再选就输了
这个就是二分图博弈问题
结论是当起始点一定在最大匹配中，先手获胜，否则先手必败。注意是一定
证明是，如果起始点不在二分图匹配中，那么首先选一条边到一个点，这个点一定是匹配点，否则就有新的匹配边，就不是最大匹配了
然后后手选匹配边。先手再选，这时先手依然选到的一定是匹配点，否则就有增广路，也不是最大匹配。这样一直下去，所有的匹配边都遍历完了之后，先手就选不了，先手输了
判断方法用二分图匹配。包含起始点和不包含起始点都做一次二分图匹配，如果匹配数不变，说明起始点可有可无，否则起始点一定在最大匹配中
这道题数据范围大用Dinic
同时不需要跑两次，先不包含起始点跑，然后加入新的边，在残量网络中再跑就行了
#include <bits/stdc++.h>
#define rep(i, a, b) for(int i = (a); i < (b); i++)
#define _for(i, a, b) for(int i = (a); i <= (b); i++)
using namespace std;
typedef long long ll;
const int N = 1e5 + 10;
struct Edge { int from, to, flow; };
vector<Edge> edge;
vector<int> g[N];
unordered_map<int, bool> mp;
int d[N], cur[N];
int n, m, s, t, start;
void add(int from, int to, int flow)
{
edge.push_back(Edge{from, to, flow});
g[from].push_back(edge.size() - 1);
edge.push_back(Edge{to, from, 0});
g[to].push_back(edge.size() - 1);
}
bool bfs()
{
memset(d, 0, sizeof(d));
queue<int> q;
q.push(s);
d[s] = 1;
while(!q.empty())
{
int u = q.front(); q.pop();
for(auto x: g[u])
{
Edge e = edge[x];
if(!d[e.to] && e.flow)
{
d[e.to] = d[u] + 1;
q.push(e.to);
}
}
}
return d[t];
}
ll dfs(int u, ll in)
{
if(u == t) return in;
ll out = 0;
for(int& i = cur[u]; i < g[u].size(); i++)
{
Edge& e = edge[g[u][i]];
if(d[u] + 1 == d[e.to] && e.flow)
{
ll f = dfs(e.to, min((ll)e.flow, in));
e.flow -= f;
edge[g[u][i] ^ 1].flow += f;
out += f; in -= f;
if(in == 0) break;
}
}
return out;
}
vector<int> get(int now) //返回所有可以达到的状态
{
vector<int> res;
string s = to_string(now);
int len = s.size();
_for(i, len, m - 1) s = "0" + s;
rep(i, 0, m)
for(int k = -1; k <= 1; k += 2)
{
string v = s;
int temp = v[i] - '0' + k;
if(temp == 10) temp = 0;
else if(temp == -1) temp = 9;
v[i] = temp + '0';
int node = stoi(v);
if(!mp[node] && node != start) res.push_back(node);
}
return res;
}
int val(int now)
{
int res = 0;
while(now) { res += now % 10; now /= 10; }
return res;
}
void build()
{
mp.clear(); edge.clear();
scanf("%d%d%d", &m, &n, &start);
s = 1e5; t = s + 1;
_for(i, 0, t) g[i].clear();
_for(i, 1, n)
{
int x; scanf("%d", &x);
mp[x] = 1;
}
_for(now, 0, pow(10, m) - 1)
if(!mp[now] && now != start)
{
if(val(now) % 2 == 1)
{
add(s, now, 1);
vector<int> v = get(now);
for(auto x: v) add(now, x, 1);
}
else add(now, t, 1);
}
}
int main()
{
int T; scanf("%d", &T);
while(T--)
{
build();
while(bfs())
{
memset(cur, 0, sizeof(cur));
dfs(s, 1e18);
}
vector<int> v = get(start);
if(val(start) % 2 == 1)
{
add(s, start, 1);
for(auto x: v) add(start, x, 1);
}
else
{
add(start, t, 1);
for(auto x: v) add(x, start, 1);
}
ll ans = 0;
while(bfs())
{
memset(cur, 0, sizeof(cur));
ans += dfs(s, 1e18);
}
puts(ans ? "Alice" : "Bob");
}
return 0;
}
poj 6191（dfs序 + 可持久化Trie）
首先用dfs序把子树转化到区间上
问题就转化为询问区间[l, r]上，一个数和区间中的数异或最大是多少
显然就是将[l, r]上的数建立字典树
同样用前缀和的思想，建立可持久化字典树
在dfs的区间上建立可持久化字典树，每次就加入区间上这个点的字典树
然后关于一开始要不要加入0的问题，看题目情况
加入0是很有意义的，意味着多了一个数
不加就正常情况，正常情况下减去root[0]是没事的，因为root[0]是空的
如果加入0就意味着root[0]加入了0，这两种情况不一样
#include<bits/stdc++.h>
#define REP(i, a, b) for(int i = (a); i < (b); i++)
#define _for(i, a, b) for(int i = (a); i <= (b); i++)
using namespace std;
const int N = 1e5 + 10;
int t[N * 35][2], val[N], root[N], vis[N * 35];
int L[N], R[N], v[N], id, n, q, cnt;
vector<int> g[N];
void add(int p, int pre, int x)
{
for(int i = 31; i >= 0; i--)
{
int idx = (x >> i) & 1;
t[p][idx] = ++cnt;
t[p][idx ^ 1] = t[pre][idx ^ 1];
p = t[p][idx]; pre = t[pre][idx];
vis[p] = vis[pre] + 1; //不要忘记写
}
}
int query(int p, int pre, int x)
{
int res = 0;
for(int i = 31; i >= 0; i--)
{
int idx = (x >> i) & 1;
if(vis[t[p][idx ^ 1]] > vis[t[pre][idx ^ 1]])
{
res |= 1 << i;
p = t[p][idx ^ 1]; pre = t[pre][idx ^ 1];
}
else p = t[p][idx], pre = t[pre][idx]; //这里原来我的，写成；查了一个半小时……
}
return res;
}
void dfs(int u)
{
L[u] = ++id;
v[id] = val[u]; //把值记录一下
for(auto x: g[u]) dfs(x);
R[u] = id;
}
int main()
{
while(~scanf("%d%d", &n, &q))
{
cnt = id = 0;
memset(t, 0, sizeof(t));
memset(vis, 0, sizeof(vis));
_for(i, 1, n)
{
scanf("%d", &val[i]);
g[i].clear();
}
_for(i, 1, n - 1)
{
int x; scanf("%d", &x);
g[x].push_back(i + 1);
}
dfs(1); //不要随便加0节点 看题目情况，加上0意味着又和0异或的情况
_for(i, 1, n) add(root[i] = ++cnt, root[i - 1], v[i]); //注意是v[i]
while(q--)
{
int u, x;
scanf("%d%d", &u, &x);
printf("%d\n", query(root[R[u]], root[L[u] - 1], x));
}
}
return 0;
}
P2617 Dynamic Rankings（支持单点修改的主席树）
之前做的主席树都是静态的，不支持修改的，现在这道题要求支持单点修改求区间第k大
如果按照原来的想法
root[i]表示1到i这个前缀线段树
那么修改a[i] 那么root[i……n]的线段树都要修改
那么一次修改的时间复杂度变成nlogn了，肯定超时
考虑怎么优化
我们要统计答案的话，是两个前缀和相减
前缀和，单点修改
用树状数组维护就很方便了
所以以前root[i]表示1到i，现在root[i] 表示树状数组中的c[i]
那么现在修改一次，就要修改logn个线段树
同理，统计前缀和也是要统计logn个线段树
由于是树状数组套线段树，多了个线段树
所以时间复杂度和空间复杂度都要多一个log
所以一次修改的时间复杂度是logn的平方，同时多开了logn的平方个节点
所以注意空间大小是nlognlogn 在这道题就要乘个400，我因为这个WA了好多次
还有一些点
之前写主席树都会复制前面节点的，这次不会
因为之前主席树是root[i] = root[i - 1] + a[i]
是要前面的root[i - 1]的，所以需要复制
而这次树状数组，平时写梳妆数组不就直接f[x]++
所以不需要复制，直接修改就好
同时新开点的前提时不存在，因为树状数组是会重复遍历一个根节点的
然后区分权值的最大值和下标的最大值，我一开始搞错了
树状数组是下标最大值，主席树中是权值最大值
#include<bits/stdc++.h>
#define REP(i, a, b) for(int i = (a); i < (b); i++)
#define _for(i, a, b) for(int i = (a); i <= (b); i++)
using namespace std;
const int N = 1e5 + 10;
int root[N << 1], ls[N * 400], rs[N * 400], t[N * 400];
int a[N], lsh[N << 1], len, cnt, n, m;
int now[20], pre[20], cntn, cntp;
struct query
{
int op, l, r, k;
}q[N];
int lowbit(int x) { return x & (-x); }
void init()
{
sort(lsh + 1, lsh + len + 1); //离散化始终用一个len 方便不容易出错
len = unique(lsh + 1, lsh + len + 1) - lsh - 1;
_for(i, 1, n) a[i] = lower_bound(lsh + 1, lsh + len + 1, a[i]) - lsh;
_for(i, 1, m) if(q[i].op == 2) q[i].r = lower_bound(lsh + 1, lsh + len + 1, q[i].r) - lsh;
}
void add(int& k, int l, int r, int x, int p)
{
if(!k) k = ++cnt; //注意这里会重复遍历到，要判断一下。以前不用判断是因为一定是新建的。写了更通用
t[k] += p; //不像之前一样复制理解，深刻理解
if(l == r) return; //add记得return
int m = l + r >> 1;
if(x <= m) add(ls[k], l, m, x, p);
else add(rs[k], m + 1, r, x, p);
}
void Add(int i, int p) //添加第i个位置的数
{
for(int x = i; x <= n; x += lowbit(x)) //len表示值域，而n表示下标，要区分开
add(root[x], 1, len, a[i], p);
}
int query(int l, int r, int k)
{
if(l == r) return l;
int x = 0;
_for(i, 1, cntn) x += t[ls[now[i]]];
_for(i, 1, cntp) x -= t[ls[pre[i]]];
int m = l + r >> 1;
if(x >= k)
{
_for(i, 1, cntn) now[i] = ls[now[i]];
_for(i, 1, cntp) pre[i] = ls[pre[i]];
return query(l, m, k);
}
else
{
_for(i, 1, cntn) now[i] = rs[now[i]];
_for(i, 1, cntp) pre[i] = rs[pre[i]];
return query(m + 1, r, k - x);
}
}
int Query(int l, int r, int k)
{
cntn = cntp = 0;
for(int x = r; x; x -= lowbit(x)) now[++cntn] = root[x]; //
for(int x = l - 1; x; x -= lowbit(x)) pre[++cntp] = root[x]; //
return query(1, len, k);
}
int main()
{
scanf("%d%d", &n, &m);
_for(i, 1, n) scanf("%d", &a[i]), lsh[++len] = a[i];
_for(i, 1, m)
{
char op[5];
int l, r, k;
scanf("%s%d%d", op, &l, &r);
if(op[0] == 'Q')
{
scanf("%d", &k);
q[i] = {1, l, r, k};
}
else q[i] = {2, l, r}, lsh[++len] = r;
}
init();
_for(i, 1, n) Add(i, 1);
_for(i, 1, m)
{
if(q[i].op == 2)
{
int x = q[i].l, y = q[i].r; //将a[x]改为y
Add(x, -1);
a[x] = y;
Add(x, 1);
}
else printf("%d\n", lsh[Query(q[i].l, q[i].r, q[i].k)]);
}
return 0;
}
M. Monster Hunter（树上背包）
好久没写树上背包了
这题要简化一下
一个点的权值是自己点加上儿子中活着的点
儿子对当前有贡献当且仅当儿子和自己都活着的时候
可以用dp[0/1][i][j]
第一维表示是否活着
第二维表示节点
第三维表示当前子树中有几个活着的点
这个活着点就有点背包中重量的味道了，于是可以写树上背包
背包九讲里面讲到了泛化背包，看作一个函数的思想很有帮助，就涉及到背包的本质了
枚举的时候有小技巧，不然会T，具体看代码
这样枚举可以做到n方的时间复杂度
#include <bits/stdc++.h>
#define rep(i, a, b) for(int i = (a); i < (b); i++)
#define _for(i, a, b) for(int i = (a); i <= (b); i++)
using namespace std;
typedef long long ll;
const int N = 2e3 + 10;
ll dp[2][N][N];
vector<int> g[N];
int siz[N], n;
void dfs(int u)
{
siz[u] = 1;
for(int v: g[u])
{
dfs(v);
for(int j = siz[u]; j >= 0; j--) //注意枚举重量是逆序枚举
_for(k, 0, siz[v])
{
dp[0][u][j + k] = min(dp[0][u][j + k], dp[0][u][j] + min(dp[0][v][k], dp[1][v][k])); //为了加速，这里用j + k
dp[1][u][j + k] = min(dp[1][u][j + k], dp[1][u][j] + min(dp[0][v][k], dp[1][v][k] + dp[1][v][1]));
}
siz[u] += siz[v];
}
}
int main()
{
int T; scanf("%d", &T);
while(T--)
{
scanf("%d", &n);
_for(i, 0, n)
_for(j, 0, n)
dp[0][i][j] = dp[1][i][j] = 1e18; //long long的最大值设为1e18 int为1e9
_for(i, 1, n) g[i].clear();
_for(i, 2, n)
{
int x; scanf("%d", &x);
g[x].push_back(i);
}
_for(i, 1, n)
{
scanf("%lld", &dp[1][i][1]); //初始化
dp[0][i][0] = 0;
}
dfs(1);
for(int i = n; i >= 0; i--) printf("%lld ", min(dp[1][1][i], dp[0][1][i])); puts(""); //最后要取min
}
return 0;
}
Matrix Equation（高斯消元）
首先对应每一位相等可以列一个方程组
固定一列后，可以列含有n个未知数的n个方程
然后高斯消元求自由变元的数量就可以了
找了个模板直接抄
注意有无解的情况
这样一算是n的四次方的
用bitset优化
#include <bits/stdc++.h>
#define rep(i, a, b) for(int i = (a); i < (b); i++)
#define _for(i, a, b) for(int i = (a); i <= (b); i++)
using namespace std;
const int N = 200 + 10;
const int mod = 998244353;
bitset<N> a[N];
int A[N][N], B[N][N], n;
int binpow(int a, int b)
{
int res = 1;
for(; b; b >>= 1)
{
if(b & 1) res = 1LL * res * a % mod;
a = 1LL * a * a % mod;
}
return res;
}
int Guess()
{
int r = 0, c = 0;
while(r < n && c < n)
{
int m_r = r;
_for(i, r + 1, n)
if(a[i][c] > a[m_r][c]) m_r = i;
if(m_r != r) swap(a[r], a[m_r]);
if(!a[r][c])
{
a[r][c] = 0;
c++;
continue;
}
_for(i, r + 1, n)
if(a[i][c])
a[i] ^= a[r];
r++; c++;
}
_for(i, r, n)
if(a[i][n])
return -1;
return n - r;
}
int main()
{
scanf("%d", &n);
rep(i, 0, n)
rep(j, 0, n)
scanf("%d", &A[i][j]);
rep(i, 0, n)
rep(j, 0, n)
scanf("%d", &B[i][j]);
int ans = 0;
rep(j, 0, n)
{
rep(i, 0, n) a[i].reset();
rep(i, 0, n)
rep(k, 0, n)
{
if(k != i) a[i][k] = A[i][k];
else a[i][k] = abs(B[i][j] - A[i][i]);
}
int t = Guess();
if(t == -1)
{
puts("0");
return 0;
}
ans += t;
}
printf("%d\n", binpow(2, ans));
return 0;
}
Shuffle Cards（stl rope 平衡树）
这道题就是用平衡树做的
但是有一个骚方法，用stl容器 rope
其内部是平衡树实现的
这个容器是用来处理字符串的，可以在logn内实现区间插入，区间删除，区间替换
数组查询O（1） 删除O（n）
链表查询O（n）删除O（1）
而这个容器，也就是平衡树，是查询O（logn） 删除O（logn）
首先要加头文件 注意万能头不包括，还要加一个using namespace
#include <ext/rope>
using namespace __gnu_cxx;
rope<int> r, x;
r.push_back(x) // 在末尾添加x
r.insert(pos,x) // 在pos插入x 区间插入
r.erase(pos,x) // 从pos开始删除x个 区间删除
r.replace(pos,x) // 从pos开始换成x 区间替换
r.substr(pos,x) // 提取pos开始x个
#include <bits/stdc++.h>
#include <ext/rope>
#define rep(i, a, b) for(int i = (a); i < (b); i++)
#define _for(i, a, b) for(int i = (a); i <= (b); i++)
using namespace std;
using namespace __gnu_cxx;
int main()
{
rope<int> r;
int n, m;
scanf("%d%d", &n, &m);
_for(i, 1, n) r.push_back(i);
while(m--)
{
int a, b;
scanf("%d%d", &a, &b);
r = r.substr(a - 1, b) + r.substr(0, a - 1) + r.substr(a + b - 1, n - a - b + 1);
}
rep(i, 0, n) printf("%d ", r[i]); puts("");
return 0;
}
E Sort String(哈希 + 输出优化)
其实就是迅速处理出这个字符串之前有没有出现过
套路是哈希配合unordered_map
我交了一发T了
这个输出巨大，所以我就加了一个输出优化
输出优化其实很简单，就是用putchar
把数拆成一位一位的然后用putchar输出
#include <bits/stdc++.h>
#define rep(i, a, b) for(int i = (a); i < (b); i++)
#define _for(i, a, b) for(int i = (a); i <= (b); i++)
using namespace std;
typedef unsigned long long ull;
const int N = 2e6 + 10;
const int base = 131;
unordered_map<ull, int> mp;
vector<int> ans[N];
ull Hash[N], p[N];
char s[N];
int n;
ull get_hash(int l, int r)
{
return Hash[r] - Hash[l - 1] * p[r - l + 1];
}
int w[60];
void write(int x)
{
int t = 0;
while(x)
{
w[++t] = x % 10;
x /= 10;
}
if(!t) putchar('0');
for(int i = t; i >= 1; i--) putchar(w[i] + '0');
}
int main()
{
scanf("%s", s + 1);
n = strlen(s + 1);
_for(i, 1, n) s[n + i] = s[i];
p[0] = 1; //不要漏这句
_for(i, 1, 2 * n)
{
p[i] = p[i - 1] * base;
Hash[i] = Hash[i - 1] * base + s[i];
}
int cnt = 0;
_for(i, 1, n)
{
ull cur = get_hash(i, i + n - 1);
if(!mp[cur]) mp[cur] = ++cnt;
ans[mp[cur]].push_back(i - 1);
}
write(cnt); puts("");
_for(i, 1, cnt)
{
write(ans[i].size()); putchar(' ');
for(auto x: ans[i]) write(x), putchar(' ');
puts("");
}
return 0;
}
D. Two Divisors（质因数分解 + 互质）
这题如果知道一个知识点就很好做了
若a, b互质 则gcd(a + b, ab) = 1
gcd(a, b) = 1 可以推出 gcd(a + b, b) = 1 gcd(a + b, a) = 1 (辗转相除法)
那么a + b 与a, b的质因数集合都没有交集
所以a + b与ab的质因数集合没有交集
这道题要求gcd(d1 + d2, ai) = 1
那么就令ab = ai就行了
所以就是把ai分解成两个互质的数b, c使得bc=ai
所以就可以把a质因数分解，选择不同的质因数集合就行了
质因数分解的话，ai给的1e7 可以用欧拉筛求出每个数的最小质因子
用最小质因子去筛，可以在logai的时间内求出质因数分解
#include <bits/stdc++.h>
#define rep(i, a, b) for(int i = (a); i < (b); i++)
#define _for(i, a, b) for(int i = (a); i <= (b); i++)
using namespace std;
const int N = 1e7 + 10;
bool vis[N];
vector<int> p;
int ans[N][2], mp[N], n;
void get_prime()
{
vis[0] = vis[1] = 1;
_for(i, 2, 1e7)
{
if(!vis[i]) p.push_back(i), mp[i] = i; //求最小质因子的时候注意质数是本身，不要漏
for(int x: p)
{
if(i * x > 1e7) break;
vis[i * x] = 1;
mp[i * x] = x;
if(i % x == 0) break;
}
}
}
int main()
{
get_prime();
scanf("%d", &n);
_for(i, 1, n)
{
int cur; scanf("%d", &cur);
int t = 1, x = mp[cur];
while(cur % x == 0)
{
cur /= x;
t *= x;
}
if(cur == 1) ans[i][0] = ans[i][1] = -1;
else
{
ans[i][0] = t;
ans[i][1] = cur;
}
}
_for(i, 1, n) printf("%d ", ans[i][0]); puts("");
_for(i, 1, n) printf("%d ", ans[i][1]); puts("");
return 0;
}
P3586 [POI2015]LOG（猜结论 + 动态开点线段树）
首先猜一个结论
大于等于s的肯定可以选
小于s的和只要大于剩下要选的数乘以s就行了
用动态开点线段树维护
#include <bits/stdc++.h>
#define rep(i, a, b) for(int i = (a); i < (b); i++)
#define _for(i, a, b) for(int i = (a); i <= (b); i++)
using namespace std;
typedef long long ll;
const int N = 1e6 + 10;
int ls[N << 6], rs[N << 6], a[N], cnt, n, m, root; //注意root一定一开始设为0
ll t1[N << 6], t2[N << 6];
void up(int k)
{
t1[k] = t1[ls[k]] + t1[rs[k]];
t2[k] = t2[ls[k]] + t2[rs[k]];
}
void modify(int& k, int l, int r, int x, int p)
{
if(!k) k = ++cnt; //动态开点
if(l == r)
{
t2[k] += p;
t1[k] = t2[k] * x;
return;
}
int m = l + r >> 1;
if(x <= m) modify(ls[k], l, m, x, p);
else modify(rs[k], m + 1, r, x, p);
up(k);
}
ll query1(int k, int l, int r, int L, int R)
{
if(!k) return 0; //询问时询问到空节点返回0
if(L <= l && r <= R) return t1[k];
int m = l + r >> 1; ll res = 0;
if(L <= m) res += query1(ls[k], l, m, L, R);
if(R > m) res += query1(rs[k], m + 1, r, L, R);
return res;
}
int query2(int k, int l, int r, int L, int R)
{
if(!k) return 0;
if(L <= l && r <= R) return t2[k];
int m = l + r >> 1, res = 0;
if(L <= m) res += query2(ls[k], l, m, L, R);
if(R > m) res += query2(rs[k], m + 1, r, L, R);
return res;
}
int main()
{
scanf("%d%d", &n, &m);
modify(root, 0, 1e9, 0, n);
while(m--)
{
char op[5]; int x, y;
scanf("%s%d%d", op, &x, &y);
if(op[0] == 'U')
{
modify(root, 0, 1e9, a[x], -1);
modify(root, 0, 1e9, a[x] = y, 1);
}
else
{
int t = query2(root, 0, 1e9, y, 1e9);
ll sum = query1(root, 0, 1e9, 0, y - 1);
if(sum >= 1LL * (x - t) * y) puts("TAK");
else puts("NIE");
}
}
return 0;
}
P3809 【模板】后缀排序
后缀数组模板
/*
sa[i] 排名为i的后缀的位置
height lcp(sa[i], sa[i - 1]) 即排名为i的后缀与排名为i−1的后缀的最长公共前缀
H[i]：height[rak[i]]，即i号后缀与它前一名的后缀的最长公共前缀
最长公共子串（可重叠） height数组最大值 因为最长公共前缀的两个子串的排名一定相邻
本质不同的字串数目 枚举每一个后缀i 对答案的贡献为 len − sa[i] + 1 − height[i]
两个后缀的最大公共前缀 令x=rank[i],y=rank[j]，x < y,那么lcp(i,j)=min(height[x+1],height[x+2]…height[y])。lcp(i,i)=n-sa[i]。 用ST表或线段树
*/
#include <bits/stdc++.h>
#define rep(i, a, b) for(int i = (a); i < (b); i++)
#define _for(i, a, b) for(int i = (a); i <= (b); i++)
using namespace std;
const int N = 1e6 + 10;
int x[N], y[N], c[N], sa[N], rk[N], height[N], wt[30];
int n, m;
char s[N];
void get_SA()
{
_for(i, 1, n) ++c[x[i] = s[i]];
_for(i, 2, m) c[i] += c[i - 1];
for(int i = n; i >= 1; i--) sa[c[x[i]]--] = i;
for(int k = 1; k <= n; k <<= 1)
{
int num = 0;
_for(i, n - k + 1, n) y[++num] = i;
_for(i, 1, n) if(sa[i] > k) y[++num] = sa[i] - k;
_for(i, 1, m) c[i] = 0;
_for(i, 1, n) ++c[x[i]];
_for(i, 2, m) c[i] += c[i - 1];
for(int i = n; i >= 1; i--) sa[c[x[y[i]]]--] = y[i], y[i] = 0;
swap(x, y);
x[sa[1]] = 1; num = 1;
_for(i, 2, n)
x[sa[i]] = (y[sa[i]] == y[sa[i - 1]] && y[sa[i] + k] == y[sa[i - 1] + k]) ? num : ++num;
if(num == n) break;
m = num;
}
}
void get_height()
{
int k = 0;
_for(i, 1, n) rk[sa[i]] = i;
_for(i, 1, n)
{
if(rk[i] == 1) continue;
if(k) k--;
int j = sa[rk[i] - 1];
while(j + k <= n && i + k <= n && s[i + k] == s[j + k]) k++;
height[rk[i]] = k;
}
}
int main()
{
scanf("%s", s + 1);
n = strlen(s + 1);
m = 122; //m表示字符个数 ascll('z')=122
//桶的范围是1~m
get_SA();
_for(i, 1, n) printf("%d ", sa[i]);
return 0;
}
P4111 [HEOI2015]小 Z 的房间（矩阵树定理 + 行列式计算）
这题看了半天思路，看了题解原来是矩阵树定理模板题……
有时不要死磕一道题太久，可能是没学过的算法
首先可以转化成图，打破一个墙看作连上一条边，两两之间只有一条道路说明是树
所以就转化成无向图的生成树计数问题
用到矩阵树定理，这是一个结论
方法是构造一个矩阵，点数是n的话，就构造一个n * n的矩阵
a[i][i]的值为点i的度数
a[i][j]就是i与j有多少条直接相连的边的相反数
这样的矩阵去掉任意一行和一列，其行列式的值就是答案
怎么求行列式的值呢
转化成对角矩阵来求
怎么转化成对角矩形
需要一列一列来消使得为0，方法是辗转相除法，可以看代码
不要看到紫题就畏惧，很多题就是高级算法的应用罢了，并没有很高的思维难度
#include <bits/stdc++.h>
#define rep(i, a, b) for(int i = (a); i < (b); i++)
#define _for(i, a, b) for(int i = (a); i <= (b); i++)
using namespace std;
typedef long long ll;
const int mod = 1e9;
const int N = 15;
int id[N][N], cnt, n, m;
ll a[N * N][N * N];
char s[N][N];
void add(int x, int y) { a[x][x]++; a[y][y]++; a[x][y]--; a[y][x]--; }
int main()
{
scanf("%d%d", &n, &m);
_for(i, 1, n) scanf("%s", s[i] + 1);
_for(i, 1, n)
_for(j, 1, m)
if(s[i][j] == '.')
id[i][j] = ++cnt;
_for(i, 1, n)
_for(j, 1, m)
{
if(s[i][j] == '.' && s[i][j + 1] == '.') add(id[i][j], id[i][j + 1]);
if(s[i][j] == '.' && s[i + 1][j] == '.') add(id[i][j], id[i + 1][j]);
}
ll ans = 1;
cnt--;
_for(j, 1, cnt - 1)
_for(i, j + 1, cnt)
while(a[i][j])
{
ll t = a[j][j] / a[i][j];
_for(k, 1, cnt) a[j][k] = (a[j][k] - t * a[i][k]) % mod;
_for(k, 1, cnt) swap(a[i][k], a[j][k]);
ans *= -1;
}
_for(i, 1, cnt) ans = ans * a[i][i] % mod;
printf("%lld\n", (ans + mod) % mod);
return 0;
}
P2447 [SDOI2010]外星千足虫（高斯消元解异或方程组）
又是新的知识点
首先要进行一个转化，我自己想的时候不知道怎么处理这个奇偶
方法是转化成异或，把奇偶转化成异或
那么这道题就成了解异或方程组了
方法是高斯消元，思想和解线性方程组类似
但是注意n个方程不一定能解出n个未知数
在解的时候，每次是寻找最靠上的不为0的系数，这个时候其实就是贪心策略，满足了题目要求的最少的方程数
然后因为只涉及0和1，所以可以用bitset优化，常数大大优化，大概是除以32
#include <bits/stdc++.h>
#define rep(i, a, b) for(int i = (a); i < (b); i++)
#define _for(i, a, b) for(int i = (a); i <= (b); i++)
using namespace std;
const int N = 2e3 + 10;
bitset<N> b[N];
int n, m, ans, flag;
void Gauss()
{
_for(j, 1, n)
{
int p = j;
while(!b[p][j] && p <= m) p++;
if(p == m + 1) { flag = 1; return; }
ans = max(ans, p);
swap(b[p], b[j]);
_for(i, 1, m)
if(i != j && b[i][j])
b[i] ^= b[j];
}
}
int main()
{
scanf("%d%d", &n, &m);
_for(i, 1, m)
_for(j, 1, n + 1)
{
int x; scanf("%1d", &x);
b[i][j] = x;
}
Gauss();
if(flag) puts("Cannot Determine");
else
{
printf("%d\n", ans);
_for(i, 1, n) puts(b[i][n + 1] ? "?y7M#" : "Earth");
}
return 0;
}
P3810 【模板】三维偏序（陌上花开）（cdq分治）
学一学cdq分治
这题是三维偏序
首先对数组排序保证第一维
然后用类似归并排序的方法，对当前的区间的左右区间分别对第二维进行排序
这样前两维的都满足了
然后就用两个指针遍历两个区间就可以了，注意要清空树状数组
注意有相同的元素，而这时cdq分治只处理左区间对右区间的贡献
所以要合并相同的元素
#include <bits/stdc++.h>
#define rep(i, a, b) for(int i = (a); i < (b); i++)
#define _for(i, a, b) for(int i = (a); i <= (b); i++)
using namespace std;
const int M = 2e5 + 10;
const int N = 1e5 + 10;
struct node
{
int a, b, c, cnt, ans;
}t[N], s[N];
int f[M], k[N], m, n;
int lowbit(int x) { return x & -x; }
void add(int x, int p)
{
for(; x <= m; x += lowbit(x))
f[x] += p;
}
int sum(int x)
{
int res = 0;
for(; x; x -= lowbit(x))
res += f[x];
return res;
}
bool cmp1(node x, node y)
{
if(x.a != y.a) return x.a < y.a;
if(x.b != y.b) return x.b < y.b;
return x.c < y.c;
}
bool cmp2(node x, node y)
{
if(x.b != y.b) return x.b < y.b;
return x.c < y.c;
}
void cdq(int l, int r)
{
if(l == r) return;
int mid = l + r >> 1;
cdq(l, mid); cdq(mid + 1, r);
sort(s + l, s + mid + 1, cmp2);
sort(s + mid + 1, s + r + 1, cmp2);
int i = l, j = mid + 1;
for(; j <= r; j++)
{
while(s[i].b <= s[j].b && i <= mid)
{
add(s[i].c, s[i].cnt);
i++;
}
s[j].ans += sum(s[j].c);
}
_for(t, l, i - 1) add(s[t].c, -s[t].cnt); //注意这里清空不是整个左区间，左区间未必遍历完
}
int main()
{
scanf("%d%d", &n, &m);
_for(i, 1, n) scanf("%d%d%d", &t[i].a, &t[i].b, &t[i].c);
sort(t + 1, t + n + 1, cmp1);
int same = 0, p = 0;
_for(i, 1, n)
{
same++;
if(t[i].a != t[i + 1].a || t[i].b != t[i + 1].b || t[i].c != t[i + 1].c)
{
s[++p] = t[i];
s[p].cnt = same;
same = 0;
}
}
cdq(1, p);
_for(i, 1, p) k[s[i].ans + s[i].cnt - 1] += s[i].cnt;
_for(i, 0, n - 1) printf("%d\n", k[i]);
return 0;
}
P3157 [CQOI2011]动态逆序对（cdq分治）
这题要转化一下
把删去的时间看作一维，这样就有3个维度，转化成三维偏序问题
其实就是求每一次删除少了多少个逆序对
也就是用cdq分治求出每一个数的贡献，这样来统计答案
那么把时间当作一维，一个数删除所产生的贡献是在它前面且大于大且时间大于它
或者在它后面且小于它且时间大于它
这就是三维偏序问题了
#include <bits/stdc++.h>
#define rep(i, a, b) for(int i = (a); i < (b); i++)
#define _for(i, a, b) for(int i = (a); i <= (b); i++)
using namespace std;
typedef long long ll;
const int N = 1e5 + 10;
struct node
{
int val, time, ans;
}a[N];
int f[N], id[N], n, m;
int lowbit(int x) { return x & -x; }
void add(int x, int p)
{
for(; x <= n; x += lowbit(x))
f[x] += p;
}
int sum(int x)
{
int res = 0;
for(; x; x -= lowbit(x))
res += f[x];
return res;
}
bool cmp1(node x, node y) { return x.val < y.val; }
bool cmp2(node x, node y) { return x.val > y.val; }
bool cmp3(node x, node y) { return x.time < y.time; }
void cdq(int l, int r)
{
if(l == r) return;
int mid = l + r >> 1;
cdq(l, mid); cdq(mid + 1, r);
sort(a + l, a + mid + 1, cmp1);
sort(a + mid + 1, a + r + 1, cmp1);
int i = l, j = mid + 1;
for(; i <= mid; i++)
{
while(a[j].val <= a[i].val && j <= r)
{
add(a[j].time, 1);
j++;
}
a[i].ans += sum(m + 1) - sum(a[i].time);
}
_for(k, mid + 1, j - 1) add(a[k].time, -1);
sort(a + l, a + mid + 1, cmp2);
sort(a + mid + 1, a + r + 1, cmp2);
i = l, j = mid + 1;
for(; j <= r; j++)
{
while(a[j].val <= a[i].val && i <= mid)
{
add(a[i].time, 1);
i++;
}
a[j].ans += sum(m + 1) - sum(a[j].time);
}
_for(k, l, i - 1) add(a[k].time, -1);
}
int main()
{
scanf("%d%d", &n, &m);
_for(i, 1, n)
{
scanf("%d", &a[i].val);
id[a[i].val] = i;
a[i].time = m + 1;
}
_for(i, 1, m)
{
int x; scanf("%d", &x);
a[id[x]].time = i;
}
ll res = 0;
_for(i, 1, n)
{
res += sum(n) - sum(a[i].val);
add(a[i].val, 1);
}
memset(f, 0, sizeof f);
cdq(1, n);
sort(a + 1, a + n + 1, cmp3);
_for(i, 1, m)
{
printf("%lld\n", res);
res -= a[i].ans;
}
return 0;
}
P3292 [SCOI2016]幸运数字(树上路径 + 线性基)
求树上一条路径的最大异或和
处理路径一般是利用lca
lca的话主要两种方法,一种倍增,一种是树链剖分
在求lca的过程中顺便维护信息
一.树上倍增
模仿倍增数组建立很多个线性基,非常暴力
然后每次合并线性基就好了,合并非常简单,插入就好了
#include<bits/stdc++.h>
#define rep(i, a, b) for(int i = (a); i < (b); i++)
#define _for(i, a, b) for(int i = (a); i <= (b); i++)
using namespace std;
typedef long long ll;
const int N = 2e4 + 10;
const int M = 62;
int d[N], up[N][22], n, q;
ll k[N][22][M + 2], ans[M + 2], a[N];
vector<int> g[N];
void read(int& x)
{
x = 0; char ch = getchar();
while(!isdigit(ch)) ch = getchar();
while(isdigit(ch)) { x = x * 10 + ch - '0'; ch = getchar(); }
}
void readll(ll& x)
{
x = 0; char ch = getchar();
while(!isdigit(ch)) ch = getchar();
while(isdigit(ch)) { x = x * 10 + ch - '0'; ch = getchar(); }
}
void add(ll *a, ll x)
{
for(int i = M; i >= 0; i--)
if(x & (1LL << i)) //一定注意这里是1LL!!!
{
if(a[i]) x ^= a[i];
else { a[i] = x; return; }
}
}
void merge(ll *a, ll *b)
{
for(int i = M; i >= 0; i--)
if(b[i])
add(a, b[i]);
}
void dfs(int u, int fa)
{
d[u] = d[fa] + 1;
up[u][0] = fa;
add(k[u][0], a[u]);
_for(j, 1, 20)
{
up[u][j] = up[up[u][j - 1]][j - 1];
memcpy(k[u][j], k[u][j - 1], sizeof k[u][j - 1]);
merge(k[u][j], k[up[u][j - 1]][j - 1]);
}
for(int v: g[u])
{
if(v == fa) continue;
dfs(v, u);
}
}
int lca(int u, int v)
{
if(d[u] < d[v]) swap(u, v);
for(int j = 20; j >= 0; j--)
if(d[up[u][j]] >= d[v])
merge(ans, k[u][j]), u = up[u][j];
if(u == v) { merge(ans, k[u][0]); return u; }
for(int j = 20; j >= 0; j--)
if(up[u][j] != up[v][j])
{
merge(ans, k[u][j]);
merge(ans, k[v][j]);
u = up[u][j]; v = up[v][j];
}
merge(ans, k[u][0]);
merge(ans, k[v][0]);
merge(ans, k[up[u][0]][0]); //注意最后还要加一个
return up[u][0]; //k数组的值是不包括跳到的点本身
}
ll qmax()
{
ll res = 0;
for(int i = M; i >= 0; i--)
res = max(res, res ^ ans[i]);
return res;
}
int main()
{
read(n); read(q);
_for(i, 1, n) readll(a[i]);
_for(i, 1, n - 1)
{
int u, v;
read(u); read(v);
g[u].push_back(v);
g[v].push_back(u);
}
dfs(1, 0);
while(q--)
{
int u, v;
read(u); read(v);
memset(ans, 0, sizeof ans);
lca(u, v);
printf("%lld\n", qmax());
}
return 0;
}
二.树链剖分 + 线段树
树链剖分转化成区间,区间用线段树维护
我们需要得到一条路径上的线性基
也就是很多个区间的线性基合并起来
区间的线性基用线段树就好了,每一个节点维护一个区间内的线性基
#include<bits/stdc++.h>
#define l(k) (k << 1)
#define r(k) (k << 1 | 1)
#define rep(i, a, b) for(int i = (a); i < (b); i++)
#define _for(i, a, b) for(int i = (a); i <= (b); i++)
using namespace std;
typedef long long ll;
const int N = 2e4 + 10;
const int M = 62;
int d[N], f[N], top[N], son[N], siz[N], n, q;
ll t[N << 2][M + 10], ans[M + 10], a[N], val[N];
int dfn[N], cnt;
vector<int> g[N];
void add(ll *a, ll x)
{
for(int i = M; i >= 0; i--)
if(x & (1LL << i))
{
if(a[i]) x ^= a[i];
else { a[i] = x; return; }
}
}
void merge(ll *a, ll *b)
{
for(int i = M; i >= 0; i--)
if(b[i])
add(a, b[i]);
}
void dfs1(int u, int fa)
{
d[u] = d[fa] + 1;
siz[u] = 1;
f[u] = fa;
for(int v: g[u])
{
if(v == fa) continue;
dfs1(v, u);
siz[u] += siz[v];
if(siz[son[u]] < siz[v]) son[u] = v;
}
}
void dfs2(int u, int t)
{
top[u] = t;
dfn[u] = ++cnt;
val[cnt] = a[u];
if(siz[u] == 1) return;
dfs2(son[u], t);
for(int v: g[u])
{
if(v == f[u] || v == son[u]) continue;
dfs2(v, v);
}
}
void up(int k)
{
merge(t[k], t[l(k)]);
merge(t[k], t[r(k)]);
}
void build(int k, int l, int r)
{
if(l == r)
{
add(t[k], val[l]);
return;
}
int m = l + r >> 1;
build(l(k), l, m);
build(r(k), m + 1, r);
up(k);
}
void query(int k, int l, int r, int L, int R)
{
if(L <= l && r <= R)
{
merge(ans, t[k]);
return;
}
int m = l + r >> 1;
if(L <= m) query(l(k), l, m, L, R);
if(R > m) query(r(k), m + 1, r, L, R);
}
void lca(int u, int v)
{
while(top[u] != top[v])
{
if(d[top[u]] < d[top[v]]) swap(u, v);
query(1, 1, n, dfn[top[u]], dfn[u]);
u = f[top[u]];
}
if(d[u] < d[v]) swap(u, v);
query(1, 1, n, dfn[v], dfn[u]);
}
ll qmax()
{
ll res = 0;
for(int i = M; i >= 0; i--)
res = max(res, res ^ ans[i]);
return res;
}
int main()
{
scanf("%d%d", &n, &q);
_for(i, 1, n) scanf("%lld", &a[i]);
_for(i, 1, n - 1)
{
int u, v;
scanf("%d%d", &u, &v);
g[u].push_back(v);
g[v].push_back(u);
}
dfs1(1, 0);
dfs2(1, 1);
build(1, 1, n);
while(q--)
{
int u, v;
scanf("%d%d", &u, &v);
memset(ans, 0, sizeof ans);
lca(u, v);
printf("%lld\n", qmax());
}
return 0;
}
xay loves trees（dfs序 + 主席树区间修改）
这题搞了很久，也收获很多
首先是一个转化，把第二颗树的祖先儿子的关系转化为dfs序的区间
这个区间有一个特点
如果有祖孙的关系的话两个区间是包含的，也就是说有交集的
否则就没有交集
那么看第一棵树，对于一个节点，它与它的祖孙最多有多少个不为祖孙的节点
其实就是看从这个节点往上最多有多少个没有交集的区间
也就是找到与当前这个区间第一个有交集的区间
第一个意味着最近，可以转化为深度最深，因此可以把区间都赋值为深度
所以就是找当前区间的深度最大值，就是第一个有交集的区间
那么这只是对于当前这个点而言，如果一条链要作为答案的话，任意两点都不能为祖孙关系
那么处理出每一个点的最近相交的点，设为hu
那么以u为深度最深的点的答案就是可以扩展到u到根节点的hu的最大值
那么要实现维护区间最大值，这里用到了可以区间修改的主席树
我还是第一次写可以区间修改的主席树，之前都是单点修改的
其实不写错的关键还是理解本质，理解主席树无非就是每次一个新版本的树，就新建一个节点，然后复制前一个树的节点的信息，然后拓展新的信息
细节写在注释里面
#include<bits/stdc++.h>
#define rep(i, a, b) for(int i = (a); i < (b); i++)
#define _for(i, a, b) for(int i = (a); i <= (b); i++)
using namespace std;
const int N = 3e5 + 10;
int ls[N << 6], rs[N << 6], t[N << 6], lazy[N << 6], root[N]; //以后写主席树一定左移6
int L[N], R[N], n, ans, cnt;
vector<int> g1[N], g2[N];
void up(int k) { t[k] = max(t[ls[k]], t[rs[k]]); }
void update(int& k, int x)
{
if(!k) { k = ++cnt; ls[k] = rs[k] = 0; } //down的时候可能是已经存在的节点，可能是新节点，小心
t[k] = lazy[k] = max(t[k], x);
}
void down(int k)
{
if(lazy[k])
{
update(ls[k], lazy[k]);
update(rs[k], lazy[k]);
lazy[k] = 0;
}
}
void add(int& k, int pre, int l, int r, int L, int R, int x)
{
k = ++cnt; //add的时候不要写!k 其复制了前一个的值 直接++cnt
t[k] = t[pre]; ls[k] = ls[pre]; rs[k] = rs[pre]; lazy[k] = lazy[pre]; //先创造新节点，然后复制值
if(L <= l && r <= R)
{
t[k] = lazy[k] = max(t[k], x);
ls[k] = rs[k] = 0; //非常重要。这时不要再左右儿子连到上一课树了。不加会错
return;
}
down(pre); //向下搜的时候,pre要down
int m = l + r >> 1;
if(L <= m) add(ls[k], ls[pre], l, m, L, R, x);
if(R > m) add(rs[k], rs[pre], m + 1, r, L, R, x);
up(k);
}
int query(int k, int l, int r, int L, int R)
{
if(!k) return 0; //可能有空节点，小心
if(L <= l && r <= R) return t[k];
down(k); //询问的时候要down
int m = l + r >> 1, res = 0;
if(L <= m) res = max(res, query(ls[k], l, m, L, R));
if(R > m) res = max(res, query(rs[k], m + 1, r, L, R));
return res;
}
void dfs(int u, int fa, int mx, int dep)
{
mx = max(mx, query(root[fa], 1, n, L[u], R[u]));
ans = max(ans, dep - mx);
add(root[u], root[fa], 1, n, L[u], R[u], dep);
for(int v: g1[u])
{
if(v == fa) continue;
dfs(v, u, mx, dep + 1);
}
}
void dfs2(int u, int fa)
{
L[u] = ++cnt;
for(int v: g2[u])
{
if(v == fa) continue;
dfs2(v, u);
}
R[u] = cnt;
}
int main()
{
int T; scanf("%d", &T);
while(T--)
{
scanf("%d", &n);
_for(i, 1, n) g1[i].clear(), g2[i].clear(), root[i] = 0;
_for(i, 1, n - 1)
{
int u, v;
scanf("%d%d", &u, &v);
g1[u].push_back(v);
g1[v].push_back(u);
}
_for(i, 1, n - 1)
{
int u, v;
scanf("%d%d", &u, &v);
g2[u].push_back(v);
g2[v].push_back(u);
}
cnt = 0;
dfs2(1, 0);
cnt = ans = 0;
dfs(1, 0, 0, 1);
printf("%d\n", ans);
_for(i, 1, cnt) ls[i] = rs[i] = t[i] = lazy[i] = 0; //结尾的时候清空
}
return 0;
}
poj 1703（带权并查集）
https://www.cnblogs.com/xzxl/p/7341536.html 这博客讲得很好 我下面的思路都是这篇博客的
带权并查集就是在原来并查集的基础上，加上了当前节点与父亲节点的关系
这样在每一个联通分量内部，就可以根据当前节点与根节点的关系来做一些事情
这道题比较骚的是不在一个联通分量，而不是以往的在一个联通分量。
仅仅有两个联通分量，这意味着，两个人和同一个人不在一个联通分量，那么它们就在一个联通分量
用r数组表示当前节点和父亲节点的关系，r[i] = 0表示在一个联通分量，r[i] = 1表示不在一个联通分量
显然初始是r[i] = 0
那么我们需要在所有的并查集操作里面更新这个r数组，就是find 和 Union 里面
先看find
我们需要从儿子与父亲的关系 和 父亲和爷爷的关系推出儿子与爷爷的关系
我们可以画一个表
儿子与父亲 父亲与爷爷 儿子与爷爷
0 0 0
0 1 1
1 0 0
1 1 1
数学上可以总结为(a +b) % 2
所以find(x)的时候就要把x和其祖先的r值都更新一遍，因为它们全都连到了这个联通分量的根
int find(int x)
{
if(f[x] == x) return x;
int fa = f[x];
f[x] = find(f[x]);
r[x] = (r[x] + r[fa]) % 2;
return f[x];
}
然后Union的时候也会改变，如x的根是fx， y的根是fy
f[fx] = fy
对于一个x，f的值改变时r的值也要改变
所以r[fx]也要改变，怎么改变呢
fx -> x -> y -> fy = fx -> fy
此时x和y的关系是不同的，看作1
void Union(int x, int y)
{
int fx = find(x), fy = find(y);
if(fx == fy) return;
f[fx] = fy;
r[fx] = (r[x] + 1 + r[y]) % 2;
}
#include <cstdio>
#define rep(i, a, b) for(int i = (a); i < (b); i++)
#define _for(i, a, b) for(int i = (a); i <= (b); i++)
using namespace std;
const int N = 1e5 + 10;
int f[N], r[N], n, m;
int find(int x)
{
if(f[x] == x) return x;
int fa = f[x];
f[x] = find(f[x]);
r[x] = (r[x] + r[fa]) % 2;
return f[x];
}
void Union(int x, int y)
{
int fx = find(x), fy = find(y);
if(fx == fy) return;
f[fx] = fy;
r[fx] = (r[x] + 1 + r[y]) % 2;
}
int main()
{
int T; scanf("%d", &T);
while(T--)
{
scanf("%d%d", &n, &m);
_for(i, 1, n) f[i] = i, r[i] = 0;
while(m--)
{
char op[5]; int x, y;
scanf("%s%d%d", op, &x, &y);
if(op[0] == 'D') Union(x, y);
else
{
if(find(x) != find(y)) puts("Not sure yet.");
else
{
if(r[x] == r[y]) puts("In the same gang.");
else puts("In different gangs.");
}
}
}
}
return 0;
}
P3224 [HNOI2012]永无乡（线段树合并 + 权值线段树求逆序对）
这题好精彩，原来权值线段树求逆序对这么方便
首先考虑一个节点，对于其左右子树，逆序对来自三个方面，左子树内部的，右子树内部的，跨越左右子树的。
可以发现，交换左右子树只影响跨越左右子树的
所以我们可以贪心，每次合并线段树都只考虑交换过后是否更少逆序对，局部最优保证全局最优
那这么求逆序对呢
因为权值里面，左儿子所有都小于右儿子的，比如对于[1, 8]
可以先考虑[1, 4] [5, 8] 贡献就是左子树中[5, 8] 数的个数乘上 右子树中[1, 4]数的个数
然后考虑[1, 2] [3, 4] 贡献类似
这样子递归下去，每一个非叶子节点都要统计答案
如果交换左右子树，就变成了左子树的[1, 4]乘上右子树的[5, 8]
#include <bits/stdc++.h>
#define rep(i, a, b) for(int i = (a); i < (b); i++)
#define _for(i, a, b) for(int i = (a); i <= (b); i++)
using namespace std;
typedef long long ll;
const int N = 2e5 + 10;
int ls[N << 5], rs[N << 5], n, cnt;
ll t[N << 5], ans, u, v;
void up(int k) { t[k] = t[ls[k]] + t[rs[k]]; }
void add(int& k, int l, int r, int x)
{
k = ++cnt;
if(l == r)
{
t[k]++;
return;
}
int m = l + r >> 1;
if(x <= m) add(ls[k], l, m, x);
else add(rs[k], m + 1, r, x);
up(k);
}
int merge(int x, int y)
{
if(!x) return y;
if(!y) return x;
t[x] += t[y];
u += t[rs[x]] * t[ls[y]];
v += t[ls[x]] * t[rs[y]];
ls[x] = merge(ls[x], ls[y]);
rs[x] = merge(rs[x], rs[y]);
return x;
}
int dfs()
{
int x, root;
scanf("%d", &x);
if(x) add(root, 1, n, x);
else
{
int lson = dfs(), rson = dfs();
u = v = 0;
root = merge(lson, rson);
ans += min(u, v);
}
return root;
}
int main()
{
scanf("%d", &n);
dfs();
printf("%lld\n", ans);
return 0;
}
Matrix Equation（高斯消元）
首先对应每一位相等可以列一个方程组
固定一列后，可以列含有n个未知数的n个方程
然后高斯消元求自由变元的数量就可以了
找了个模板直接抄
注意有无解的情况
这样一算是n的四次方的
用bitset优化
#include <bits/stdc++.h>
#define rep(i, a, b) for(int i = (a); i < (b); i++)
#define _for(i, a, b) for(int i = (a); i <= (b); i++)
using namespace std;
const int N = 200 + 10;
const int mod = 998244353;
bitset<N> a[N];
int A[N][N], B[N][N], n;
int binpow(int a, int b)
{
int res = 1;
for(; b; b >>= 1)
{
if(b & 1) res = 1LL * res * a % mod;
a = 1LL * a * a % mod;
}
return res;
}
int Guess()
{
int r = 0, c = 0;
while(r < n && c < n)
{
int m_r = r;
_for(i, r + 1, n)
if(a[i][c] > a[m_r][c]) m_r = i;
if(m_r != r) swap(a[r], a[m_r]);
if(!a[r][c])
{
a[r][c] = 0;
c++;
continue;
}
_for(i, r + 1, n)
if(a[i][c])
a[i] ^= a[r];
r++; c++;
}
_for(i, r, n)
if(a[i][n])
return -1;
return n - r;
}
int main()
{
scanf("%d", &n);
rep(i, 0, n)
rep(j, 0, n)
scanf("%d", &A[i][j]);
rep(i, 0, n)
rep(j, 0, n)
scanf("%d", &B[i][j]);
int ans = 0;
rep(j, 0, n)
{
rep(i, 0, n) a[i].reset();
rep(i, 0, n)
rep(k, 0, n)
{
if(k != i) a[i][k] = A[i][k];
else a[i][k] = abs(B[i][j] - A[i][i]);
}
int t = Guess();
if(t == -1)
{
puts("0");
return 0;
}
ans += t;
}
printf("%d\n", binpow(2, ans));
return 0;
}
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
