A The Contest
直接粗暴贪心 略过
#include
using namespace std;
int main()
{//freopen("t.txt","r",stdin);
long long int n,sum=0,k;
scanf("%lld",&n);
for(int i=0;i B The Golden Age
由于指数增长速度极快 直接用一个平衡树遍历即可。
#include
using namespace std;
typedef long long int LL;
const LL N=1e18+1;
LL x[100],y[100];
maps;
int main()
{//freopen("t.txt","r",stdin);
LL l,r;
s.clear();
scanf("%lld%lld%lld%lld",&x[1],&y[1],&l,&r);
x[0]=y[0]=1;
for(int i=2;i<100&&x[i-1]*x[1]<=N&&x[i-1]<=(N/x[1])&&x[i-1]*x[1]>=0&&(!(x[i-1]>1e+9&&x[1]>1e+9));i++)
x[i]=x[i-1]*x[1];
for(int i=2;i<100&&y[i-1]*y[1]<=N&&y[i-1]<=(N/y[1])&&y[i-1]*y[1]>=0&&(!(y[i-1]>1e+9&&y[1]>1e+9));i++)
y[i]=y[i-1]*y[1];
for(int a=0;x[a]<=N&&x[a]!=0;a++)
for(int b=0;y[b]<=N&&y[b]!=0;b++ )
{
//if(a==b)continue;
if(x[a]<0||y[b]<0)continue;
if(x[a]+y[b]<=r&&x[a]+y[b]>=l&&s.count(x[a]+y[b])==0)s[x[a]+y[b]]=1;
}
map::iterator it,ipt;
LL ans=0,len=0;
s[l-1]=s[r+1]=1;
it=s.begin();
ipt=s.begin();
it++;
for(;it!=s.end();it++,ipt++)
{
//cout<first<<" "<first<first-ipt->first-1);
}
printf("%lld\n",ans);
return 0;
}
C The Tag Game
很简单的贪心 Bob总是要前往最深的节点（在不撞到Alice的前提下）
遍历一下即可
#include
using namespace std;
const int N=2e5+1;
int fa[N],dep[N],len[N];
vectoradj[N];
int n,x;
int dfs(int cur,int father,int lens)
{
dep[cur]=lens;
len[cur]=0;
fa[cur]=father;
for(int i=0;i D Two Melodies
O(n^2)的dp 设dp[i][j]为 第一个Melody在i处结束 第二个Melody在j处结束 显然有 dp[i][j]=dp[j][i]
具体转移方法看代码吧 很清晰
# include
#include
using namespace std;
long long i,j,n,mx,a[5009],b[5009][5009],x[9],y[100009];
int main()
{
cin>>n;
for (i=1;i<=n;i++) cin>>a[i];
for (i=0;i<=n;i++)
{
for (j=0;j<=7;j++) x[j]=0;
for (j=1;j<=n;j++) y[a[j]]=0;
for (j=1;j
E Army Creation
技巧性很强的一道线段树题
我们首先考虑解决一个问题：对于某个士兵，它有可能对哪个区间造成超员？
假设该士兵的位置是d 对于同种类的士兵 往前数k个的位置的士兵 它的位置是b 那么对于区间【1，b】 位置d的士兵会造成他们超员
用线段树可以在对数时间内解决第一个问题。
那么对于题中询问[L,R] 我们只要统计使得区间[L,R]可能超员的士兵 位置小于等于R的个数即可。
总的复杂度 O（nlog^2n）
不过这个代码写的和一般的线段树还不太一样
#include
using namespace std;
const int Maxn = 100005;
const int Maxm = 524288;
int n, k;
int a[Maxn];
vector I[Maxn];
vector st[Maxm];
int q;
int res;
void Insert(int v, int l, int r, int a, int b, int val)
{
if (l == a && r == b) st[v].push_back(val);
else {
int m = l + r >> 1;
if (a <= m) Insert(2 * v, l, m, a, min(m, b), val);//重复添加
if (m + 1 <= b) Insert(2 * v + 1, m + 1, r, max(m + 1, a), b, val);
}
}
int Get(int v, int l, int r, int x, int R)
{
int res = upper_bound(st[v].begin(), st[v].end(), R) - st[v].begin();
if (l < r) {
int m = l + r >> 1;
if (x <= m) res += Get(2 * v, l, m, x, R);//避免重复计算
else res += Get(2 * v + 1, m + 1, r, x, R);
}
return res;
}
int main()
{
scanf("%d %d", &n, &k);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
I[a[i]].push_back(i);
if (I[a[i]].size() > k) Insert(1, 1, n, 1, I[a[i]][I[a[i]].size() - k - 1], i);
}
scanf("%d", &q);
while (q--) {
int x, y; scanf("%d %d", &x, &y);
x = (x + res) % n + 1;
y = (y + res) % n + 1;
if (x > y) swap(x, y);
res = (y - x + 1) - Get(1, 1, n, x, y);
printf("%d\n", res);
}
return 0;
}
F Bipartite Checking
很具有扩展性的一道题 可以联想到很多问题
官方题解很详细 直接引用
简单概述一下：我们转化问题 对于每条边 我们考虑它覆盖了那些询问 比如对于第i个询问 我们只需要考虑覆盖了它的边即可。
用分治法dfs的时候 我们需要添加边，可以简单做到，删除边该怎么做呢？ 把图的信息当作一个栈回溯即可。(分治的过程满足后进先出的性质，所以可以用栈）
复杂度不高，但是常数真的大。
下面引用原文。
If the edges were only added and not deleted, it would be a common problem that is solved with disjoint set union. All you need to do in that problem is implement a DSU which maintains not only the leader in the class of some vertex, but also the distance to this leader. Then, if we try to connect two vertices that have the same leader in DSU and the sum of distances to this leader is even, then we get a cycle with odd length, and graph is no longer bipartite.
But in this problem we need to somehow process removing edges from the graph.
In the algorithm I will describe below we will need to somehow remove the last added edge from DSU (or even some number of last added edges). How can we process that? Each time we change some variable in DSU, we can store an address of this variable and its previous value somewhere (for example, in a stack). Then to remove last added edge, we rollback these changes — we rewrite the previous values of the variables we changed by adding the last edge.
Now we can add a new edge and remove last added edge. All these operations cost (O(logn)) because we won't use path compression in DSU — path compression doesn't work in intended time if we have to rollback. Let's actually start solving the problem.
For convinience, we change all information to queries like "edge (x, y) exists from query number l till query number r". It's obvious that there are no more than q such queries. Let's use divide-and-conquer technique to make a function that answers whether the graph is bipartite or not after every query from some segment of queries [a, b]. First of all, we add to DSU all the edges that are present in the whole segment (and not added yet); then we solve it recursively for 
and 
; then we remove edges from DSU using the rollback technique described above. When we arrive to some segment [a, a], then after adding the edges present in this segment we can answer if the graph is bipartite after query a. Remember to get rid of the edges that are already added and the edges that are not present at all in the segment when you make a recursive call. Of course, to solve the whole problem, we need to call our function from segment [1, q].
Time complexity is 
, because every edge will be added only in 
calls of the function.
#include
#include
#include