bzoj Ac代码集 Start-2016年10月10日

最新推荐文章于 2018-09-17 11:16:08 发布
正汰
最新推荐文章于 2018-09-17 11:16:08 发布
阅读量1.5k
点赞数
分类专栏： BZOJ C++算法大全
本文链接：https://blog.youkuaiyun.com/huangzhengdoc/article/details/52776738
版权
C++算法大全同时被 2 个专栏收录
87 篇文章
订阅专栏
BZOJ
39 篇文章
订阅专栏
代码很长，大家慢慢，这是整合，还有很多我没写博客的，大家都可以在这里找找

Problem1001

#include<cmath>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<iostream>
#include<algorithm>
using namespace std;
struct node{
    int x,y,c,next,other;
}a[6100000];int len,first[1100000];
void ins(int x,int y,int c){
    int kx,ky;
    len++;kx=len;
    a[len].x=x;a[len].y=y;a[len].c=c;
    a[len].next=first[x];first[x]=len;
    len++;ky=len;
    a[len].x=y;a[len].y=x;a[len].c=c;
    a[len].next=first[y];first[y]=len;         
    a[kx].other=ky;a[ky].other=kx;
}
int h[1100000],list[1100000],head,tail,st,ed;
bool bt(){
    memset(h,0,sizeof(h));h[st]=1;
    list[1]=st;head=1;tail=2;
    while(head!=tail){
        int x=list[head];
        for(int k=first[x];k!=0;k=a[k].next){
            int y=a[k].y;
            if(a[k].c>0&&h[y]==0){
                h[y]=h[x]+1;
                list[tail++]=y;
            }
        }
        head++;
    }
    if(h[ed]>0)return true;
    else return false;
}   
int findflow(int x,int f){
    if(x==ed)return f;
    int s=0,tmp;
    for(int k=first[x];k!=0;k=a[k].next){
        int y=a[k].y;
        if(a[k].c>0&&h[y]==h[x]+1&&s<f){
            tmp=findflow(y,min(a[k].c,f-s));
            s+=tmp;
            a[k].c-=tmp;a[a[k].other].c+=tmp;
        }
    }
    if(s==0)h[x]=0;
    return s;
}
int main(){
    int n,m;
    while(scanf("%d%d",&n,&m)!=EOF){
        st=1;ed=n*m;
        len=0;memset(first,0,sizeof(first));
        for(int i=1;i<=n;i++){
            for(int j=1;j<=m-1;j++){
                int z;
                scanf("%d",&z);
                ins((i-1)*m+j,(i-1)*m+j+1,z);//ins((i-1)*m+j+1,(i-1)*m+j,z);
                //printf("[%d %d]\n",(i-1)*4+j,(i-1)*4+j+1);
            }
        }
        for(int i=1;i<=n-1;i++){
            for(int j=1;j<=m;j++){
                int z;
                scanf("%d",&z);
                ins((i-1)*m+j,i*m+j,z);//ins(i*m+j,(i-1)*m+j,z);
                //printf("[%d %d]\n",(i-1)*4+j,i*4+j);
            }
        }
        for(int i=1;i<=n-1;i++){
            for(int j=1;j<=m-1;j++){
                int z;
                scanf("%d",&z);
                ins((i-1)*m+j,i*m+j+1,z);//ins(i*m+j+1,(i-1)*m+j,z);
                //printf("[%d %d]\n",(i-1)*4+j,i*4+j+1);
            }
        }
        int ans=0;
        while(bt()==true){
            ans+=findflow(st,99999999);
        }
        printf("%d\n",ans);
    }
    return 0;
}
/*
3 4
5 6 4
4 3 1
7 5 3
5 6 7 8
8 7 6 5
5 5 5
6 6 6
*/
Problem1002

#include<cmath>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<iostream>
#include<algorithm>
using namespace std;
struct node{
    int a[110],len;
}f[110];
int n;
node chengfa(node X,int k){
    for(int i=1;i<=X.len;i++)X.a[i]*=k;
    for(int i=1;i<=X.len;i++){
        X.a[i+1]+=X.a[i]/10;
        X.a[i]%=10;
    }
    if(X.a[X.len+1]!=0)X.len++;
    return X;
} 
node jianfa(node X,node Y){
    X.a[1]+=2;
    int j=1;while(X.a[j]>=10){X.a[j]%=10;X.a[++j]++;} 
    for(int i=1;i<=X.len;i++){
        X.a[i]-=Y.a[i];
        if(X.a[i]<0){
            X.a[i]+=10;
            X.a[i+1]--;
        }
    }
    while(X.a[X.len]==0)X.len--;
    return X;
}
int main(){
    f[1].a[1]=1;f[2].a[1]=5;
    f[1].len=f[2].len=1;
    scanf("%d",&n);
    for(int i=3;i<=n;i++)f[i]=jianfa(chengfa(f[i-1],3),f[i-2]);
    for(int i=f[n].len;i>0;i--)printf("%d",f[n].a[i]);
    return 0;
}
Problem1003

#include<cmath>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<iostream>
#include<algorithm>
using namespace std;
struct node{
    int x,y,d,next;
}a[1100000];
int len,first[1100];
void ins(int x,int y,int d){
    len++;
    a[len].x=x;a[len].y=y;a[len].d=d;
    a[len].next=first[x];first[x]=len;
}
int list[1100],head,tail,n,m,K,e,d[1100],g[1100][1100],x,y,z,p,flag[1100][1100],f[1100];
int bfs(int st,int ed){
    for(int i=1;i<=m;i++)d[i]=999999;
    list[1]=1;d[1]=0;
    head=1;tail=2;
    while(head!=tail){
        x=list[head];
        for(int k=first[x];k>0;k=a[k].next){
            y=a[k].y;
            if((flag[y][ed]-flag[y][st-1]==0)&&(d[y]>d[x]+a[k].d)){
                d[y]=d[x]+a[k].d;
                list[tail++]=y;if(tail==m+1)tail=1;
            }
        }
        head++;if(head==m+1)head=1;
    }
    return d[m]; 
}
int main(){
    scanf("%d%d%d%d",&n,&m,&K,&e);
    memset(g,0,sizeof(g)); 
    for(int i=1;i<=e;i++){
        scanf("%d%d%d",&x,&y,&z);
        if(g[x][y]==0||g[x][y]>z)g[x][y]=g[y][x]=z;
    }
    len=0;memset(first,0,sizeof(first));
    for(int i=1;i<=m;i++){
        for(int j=i+1;j<=m;j++){
            if(g[i][j]>0){
                ins(i,j,g[i][j]);
                ins(j,i,g[i][j]);
            }
        }
    }
    scanf("%d",&p);
    memset(flag,0,sizeof(flag));
    for(int i=1;i<=p;i++){
        scanf("%d%d%d",&z,&x,&y);
        for(int j=x;j<=y;j++)flag[z][j]=1;
    }
    for(int i=1;i<=m;i++){
        for(int j=1;j<=n;j++){
            flag[i][j]=flag[i][j-1]+flag[i][j];
        }
    }
    f[0]=0;
    for(int i=1;i<=n;i++){
        f[i]=999999;
        for(int j=1;j<=i;j++){
            int tmp=bfs(j,i);
            if(f[i]>f[j-1]+tmp*(i-j+1)+K)f[i]=f[j-1]+tmp*(i-j+1)+K;
        }
    }
    printf("%d\n",f[n]-K);
    return 0;
}
/*
---IN PUT---
5 5 10 8
1 2 1
1 3 3
1 4 2
2 3 2
2 4 4
3 4 1
3 5 2
4 5 2
4
2 2 3
3 1 1             
3 3 3
4 4 5
---OUT PUT---
32
*/
Problem1008

#include<cmath>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<iostream>
#include<algorithm>
using namespace std;
long long c=100003;
long long pow_mod(long long a,long long b){
    long long ans=1%c;a%=c;
    while(b){
        if(b&1)ans=ans*a%c;
        b>>=1;a=a*a%c;
    }
    return ans;
}
int main(){
    long long n,m;
    scanf("%lld%lld",&m,&n);
    long long x=pow_mod(m,n);
    long long y=m*pow_mod(m-1,n-1)%c;
    long long s=(x-y+c)%c;
    printf("%lld",s);
}
Problem1010

#include<cmath>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<iostream>
#include<algorithm>
using namespace std;
int a[510000],q[510000],n,L,l,r;
long long s[510000],f[510000];
double slop(int j,int k){
    return (f[k]+(s[k]+L)*(s[k]+L)-f[j]-(s[j]+L)*(s[j]+L))/(2.0*(s[k]-s[j]));
}
int main(){
    scanf("%d%d",&n,&L);L++;
    s[0]=0;
    for(int i=1;i<=n;i++){
        scanf("%d",&a[i]);a[i]++;
        s[i]=s[i-1]+a[i];
    }
    q[1]=0;l=r=1;
    for(int i=1;i<=n;i++){
        while(l<r&&slop(q[l],q[l+1])<=s[i])l++;
        int tmp=q[l];
        f[i]=f[tmp]+(s[i]-s[tmp]-L)*(s[i]-s[tmp]-L);
        while(l<r&&slop(q[r],i)<slop(q[r-1],q[r]))r--;
        q[++r]=i;
    }
    printf("%lld",f[n]);
    return 0;
}   
Problem1010

#include<cmath>
#include<cstdio>
#include<cstring>   
#include<cstdlib>
#include<iostream>
#include<algorithm>
using namespace std;
int a[510000],q[510000],n,m,L,l,r;
long long s[510000],f[510000];
double Y(int k){
    return (f[k]+(s[k]+L)*(s[k]+L));
}
double X(int k){
    return s[k];
}
double slop(int j,int k){
    return (Y(k)-Y(j))/(2.0*(X(k)-X(j)));
}
int main(){
    scanf("%d%d",&n,&L);L++;s[0]=0;
    for(int i=1;i<=n;i++){
        scanf("%d",&a[i]);a[i]++;
        s[i]=s[i-1]+a[i];
    }
    q[1]=0;l=r=1;
    for(int i=1;i<=n;i++){
        while(l<r&&slop(q[l],q[l+1])<=s[i])l++;
        int tmp=q[l];
        f[i]=f[tmp]+(s[i]-s[tmp]-L)*(s[i]-s[tmp]-L);
        while(l<r&&slop(q[r],i)<slop(q[r-1],q[r]))r--;
        q[++r]=i;
    }
    printf("%lld",f[n]);
    return 0;
}   
Problem1012

#include<cmath>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<iostream>
#include<algorithm>
using namespace std;
struct tree{
    int l,r,lc,rc;
    long long c;  
}tr[510000];
int trlen,n,l,len;
long long t;
void bt(int l,int r){
    trlen++;int now=trlen;
    tr[now].l=l;tr[now].r=r;tr[now].c=0; 
    tr[now].lc=tr[now].rc=-1;
    if(l<r){
        int mid=(l+r)/2;
        tr[now].lc=trlen+1;bt(l,mid);
        tr[now].rc=trlen+1;bt(mid+1,r);
    }
}
void change(int now,int p,long long c){
    if(tr[now].l==tr[now].r){tr[now].c=c;return ;}
    int lc=tr[now].lc,rc=tr[now].rc,mid=(tr[now].l+tr[now].r)/2;
    if(p<=mid)change(lc,p,c);
    else change(rc,p,c);
    tr[now].c=max(tr[lc].c,tr[rc].c);
}
long long findmax(int now,int l,int r){
    if(tr[now].l==l&&tr[now].r==r)return tr[now].c;
    int lc=tr[now].lc,rc=tr[now].rc,mid=(tr[now].l+tr[now].r)/2;    
    if(mid+1<=l)return findmax(rc,l,r);
    else if(r<=mid)return findmax(lc,l,r);
    else return max(findmax(lc,l,mid),findmax(rc,mid+1,r));
}
int main(){
    scanf("%d%d",&n,&l);
    trlen=len=t=0;bt(1,210000);
    char s[10];long long x; 
    for(int i=1;i<=n;i++){
        scanf("%s%lld",s,&x);
        if(s[0]=='A')change(1,++len,(x+t)%l);
        else{
            t=findmax(1,len-x+1,len);
            printf("%d\n",t);
        }
    }
}
/*
---输入---
5 100
A 96
Q 1
A 97
Q 1
Q 2 
---输出---
96
93
96
*/
Problem1013

#include<set>
#include<map>
#include<cmath>
#include<cstdio>
#include<vector>
#include<cstring>
#include<cstdlib>
#include<iostream>
#include<algorithm>
using namespace std;
int n;
double a[31][31],b[31][31],x[31];
void gauss(){
    for(int i=1;i<n;i++){
        for(int j=i+1;j<=n;j++){
            double tmp=a[j][i]/a[i][i];
            for(int k=i;k<=n+1;k++)a[j][k]-=tmp*a[i][k];
        }
    }
    x[n]=a[n][n+1]/a[n][n];
    for(int i=n-1;i>=1;i--){
        double tmp=a[i][n+1];
        for(int j=i+1;j<=n;j++)tmp-=a[i][j]*x[j];
        x[i]=tmp/a[i][i];
    }
}
int main(){
    scanf("%d",&n);
    for(int i=1;i<=n+1;i++){
        for(int j=1;j<=n;j++){
            scanf("%lf",&b[i][j]);
        }   
    }
    for(int i=1;i<=n;i++){
        a[i][n+1]=0;
        for(int j=1;j<=n;j++){
            a[i][n+1]+=b[i+1][j]*b[i+1][j]-b[i][j]*b[i][j];
            a[i][j]=2*(b[i+1][j]-b[i][j]);
        }
    }
    gauss();
    for(int i=1;i<n;i++)printf("%.3lf ",x[i]);printf("%.3lf\n",x[n]);
} 
Problem1013

#include<set>
#include<map>
#include<cmath>
#include<cstdio>
#include<vector>
#include<cstring>
#include<cstdlib>
#include<iostream>
#include<algorithm>
#define esp 1e-8
using namespace std;
int n;
double a[31][31],b[31][31],x[31];
void gauss(){
    for(int i=1;i<n;i++){
        int p=0;
        for(int j=i;j<=n;j++){
            if(fabs(a[j][i])>esp){
                p=i;break;
            }
        }
        for(int j=1;j<=n;j++)swap(a[i][j],a[p][j]);
        for(int j=i+1;j<=n;j++){
            if(fabs(a[j][i])>esp){
                double tmp=a[j][i]/a[i][i];
                for(int k=i;k<=n+1;k++)a[j][k]-=tmp*a[i][k];
            }
        }
    }
    x[n]=a[n][n+1]/a[n][n];
    for(int i=n-1;i>=1;i--){
        double tmp=a[i][n+1];
        for(int j=i+1;j<=n;j++)tmp-=a[i][j]*x[j];
        x[i]=tmp/a[i][i];
    }
}
int main(){
    scanf("%d",&n);
    for(int i=1;i<=n+1;i++){
        for(int j=1;j<=n;j++){
            scanf("%lf",&b[i][j]);
        }   
    }
    for(int i=1;i<=n;i++){
        a[i][n+1]=0;
        for(int j=1;j<=n;j++){
            a[i][n+1]+=b[i+1][j]*b[i+1][j]-b[i][j]*b[i][j];
            a[i][j]=2*(b[i+1][j]-b[i][j]);
        }
    }
    gauss();
    for(int i=1;i<n;i++)printf("%.3lf ",x[i]);printf("%.3lf\n",x[n]);
} 
Problem1015

#include<cstdio>
#include<cstring>
using namespace std;
struct node
{
    int x,next;
}a[510000];int first[510000],sum;
int len;
void ins(int x,int y)
{
    a[++len].x=y;a[len].next=first[x];first[x]=len;
    a[++len].x=x;a[len].next=first[y];first[y]=len;
}                                                                                                                
int s[510000];
int fa[510000];bool v[510000],vs[510000];                                                                
int findfa(int x)                                                           
{                                                      
    if(x!=fa[x])fa[x]=findfa(fa[x]);
    return fa[x];                                                      
}
void add(int x){
    int xf=findfa(x);
    for(int k=first[x];k>0;k=a[k].next){
        if(vs[a[k].x]==true){
            int yf=findfa(a[k].x);
            if(xf!=yf){
                fa[yf]=x;sum--; 
            }
        }
    }
}
int ss[510000];
int main()
{
    int n,m;scanf("%d%d",&n,&m);
    for(int i=0;i<n;i++) fa[i]=i;
    len=0;for(int i=1;i<=m;i++){
        int xx,yy;
        scanf("%d%d",&xx,&yy);
        ins(xx,yy);
    }
    int k;scanf("%d",&k);
    memset(v,true,sizeof(v));
    memset(vs,false,sizeof(vs));sum=0;
    for(int i=1;i<=k;i++) {scanf("%d",&s[i]);v[s[i]]=false;}
    for(int i=0;i<n;i++){
         if(v[i]==true){
             sum++;
             add(i);
             vs[i]=true;
         }
    }
    int ans[510000];
    ans[k+1]=sum;
    for(int i=k;i>=1;i--) 
    {
        sum++;
        add(s[i]);
        vs[s[i]]=true;
        ans[i]=sum;
    }
    for(int i=1;i<=k+1;i++)printf("%d\n",ans[i]);
    return 0;
}
Problem1015

#include<set>
#include<map>
#include<cmath>
#include<cstdio>
#include<vector>
#include<cstring>
#include<cstdlib>
#include<iostream>
#include<algorithm>
using namespace std;
struct node{
    int x,next;
}a[510000];//结构体，表示连接到x这个点 
int n,m,k,len,sum,f[510000],first[510000],fa[510000],ans[510000];
bool v[510000],b[510000];
void ins(int x,int y){
    len++;a[len].x=y;a[len].next=first[x];first[x]=len;
    len++;a[len].x=x;a[len].next=first[y];first[y]=len;//建边 
}   
int findfa(int x){
    if(x==fa[x])return fa[x];//找祖先 
    return fa[x]=findfa(fa[x]);
}
void add(int x){
    int xf=findfa(x);
    for(int k=first[x];k>0;k=a[k].next){ //v代表边现在存在 
        if(v[a[k].x]==true){
            int yf=findfa(a[k].x);
            if(xf!=yf){
                fa[yf]=x;sum--;//如果祖先不一样的话，统一祖先，联通块-1 
            }
        }
    }
}
int main(){
    scanf("%d%d",&n,&m);
    for(int i=0;i<n;i++)fa[i]=i;
    len=0;memset(first,0,sizeof(first));
    for(int i=1;i<=m;i++){
        int x,y;
        scanf("%d%d",&x,&y);
        ins(x,y);//建边不解释 
    }
    scanf("%d",&k);
    memset(b,false,sizeof(b));
    memset(v,false,sizeof(v));
    for(int i=1;i<=k;i++){
        scanf("%d",&f[i]);
        b[f[i]]=true;//如果不会被炸毁的先标记下来下边可以用上 
    }
    for(int i=0;i<n;i++){//是0到n-1,好坑爹 
        if(b[i]==false){//没被炸毁的先建边 
            sum++;add(i);
            v[i]=true;//建了边代表存在的 
        }
    }
    ans[k+1]=sum;//k+1代表最后炸毁的状态 
    for(int i=k;i>0;i--){
        sum++;//好，我们再模拟，一个一个把点加上去 
        add(f[i]);//加点 
        v[f[i]]=true;//很好这条边已经存在了 
        ans[i]=sum;//记录值 
    }
    for(int i=1;i<=k+1;i++)printf("%d\n",ans[i]);//输出 
}
Problem1016

#include<set>
#include<map>
#include<cmath>
#include<cstdio>
#include<vector>
#include<cstring>
#include<cstdlib>
#include<iostream>
#include<algorithm>
using namespace std;
int mod=31011,n,m,tot,cnt,ans,sum,fa[110000];
struct node{
    int x,y,d;
}a[110000];
struct data{
    int l,r,v;
}ar[110000];
int cmp(const void *xx,const void *yy){
    node x=*(node *)xx;
    node y=*(node *)yy;
    return x.d-y.d;
}
int findfa(int x){
    if(x!=fa[x])return findfa(fa[x]);
    else return x;
}
void dfs(int x,int now,int k){
    if(now==ar[x].r+1){
        if(k==ar[x].v)sum++;
        return;
    }
    int p=findfa(a[now].x),q=findfa(a[now].y);
    if(p!=q){
        fa[p]=q;
        dfs(x,now+1,k+1);
        fa[p]=p;fa[q]=q;
    }
    dfs(x,now+1,k);
}
int main(){
    scanf("%d%d",&n,&m);
    for(int i=1;i<=m;i++) scanf("%d%d%d",&a[i].x,&a[i].y,&a[i].d);
    qsort(a+1,m,sizeof(node),cmp);
    for(int i=1;i<=n;i++)fa[i]=i;
    cnt=tot=0;
    for(int i=1;i<=m;i++){
        if(a[i].d!=a[i-1].d){
            ar[++cnt].l=i;ar[cnt].v=0;ar[cnt-1].r=i-1;
        }
        int p=findfa(a[i].x),q=findfa(a[i].y);
        if(p!=q){
            fa[p]=q;ar[cnt].v++;tot++;
        }
    } 
    ar[cnt].r=m;
    if(tot!=n-1){printf("0\n");return 0;}
    for(int i=1;i<=n;i++)fa[i]=i;
    ans=1;
    for(int i=1;i<=cnt;i++){
        sum=0;
        dfs(i,ar[i].l,0);
        ans=(ans*sum)%mod;
        for(int j=ar[i].l;j<=ar[i].r;j++){
            int p=findfa(a[j].x),q=findfa(a[j].y);
            if(p!=q)fa[p]=q;
        }
    }
    printf("%d",ans);
}
Problem1016

#include<set>
#include<map>
#include<cmath>
#include<cstdio>
#include<vector>
#include<cstring>
#include<cstdlib>
#include<iostream>
#include<algorithm>
using namespace std;
int mod=31011,n,m,tot,cnt,ans,sum,fa[110000];
struct node{
    int x,y,d;
}a[110000];
struct data{
    int l,r,v;
}ar[110000];
int cmp(const void *xx,const void *yy){
    node x=*(node *)xx;
    node y=*(node *)yy;
    return x.d-y.d;
}
int findfa(int x){
    if(x!=fa[x])return findfa(fa[x]);
    else return x;
}
void dfs(int x,int now,int k){
    if(now==ar[x].r+1){
        if(k==ar[x].v)sum++;
        return;
    }
    int p=findfa(a[now].x),q=findfa(a[now].y);
    if(p!=q){
        fa[p]=q;
        dfs(x,now+1,k+1);
        fa[p]=p;fa[q]=q;
    }
    dfs(x,now+1,k);
}
int main(){
    scanf("%d%d",&n,&m);
    for(int i=1;i<=m;i++) scanf("%d%d%d",&a[i].x,&a[i].y,&a[i].d);
    qsort(a+1,m,sizeof(node),cmp);
    for(int i=1;i<=n;i++)fa[i]=i;
    cnt=tot=0;
    for(int i=1;i<=m;i++){
        if(a[i].d!=a[i-1].d){
            ar[++cnt].l=i;ar[cnt].v=0;ar[cnt-1].r=i-1;
        }
        int p=findfa(a[i].x),q=findfa(a[i].y);
        if(p!=q){
            fa[p]=q;ar[cnt].v++;tot++;
        }
    } 
    ar[cnt].r=m;
    if(tot!=n-1){printf("0\n");return 0;}
    for(int i=1;i<=n;i++)fa[i]=i;
    ans=1;
    for(int i=1;i<cnt;i++){
        sum=0;
        dfs(i,ar[i].l,0);
        ans=(ans*sum)%mod;
        for(int j=ar[i].l;j<=ar[i].r;j++){
            int p=findfa(a[j].x),q=findfa(a[j].y);
            if(p!=q)fa[p]=q;
        }
    }
    sum=0;
    dfs(cnt,ar[cnt].l,0);
    ans=(ans*sum)%mod;
    printf("%d\n",ans);
}
Problem1019

#include<cmath>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<iostream>
#include<algorithm>
typedef long long LL;
using namespace std;
int p[4][40],n,from[10],to[10];
LL f[5][40];
int main(){
    scanf("%d",&n);
    char s[10];
    for(int i=1;i<=6;i++){
        scanf("%s",s+1);
        from[i]=s[1]-'A'+1;to[i]=s[2]-'A'+1;
    }
    for(int i=1;i<=3;i++)f[i][1]=1;
    for(int i=6;i>=1;i--)p[from[i]][1]=to[i];
    for(int i=2;i<=n;i++){
        for(int a=1;a<=3;a++){
            int b=p[a][i-1],c=6-a-b;
            if(p[b][i-1]==c){
                f[a][i]=f[a][i-1]+1+f[b][i-1];
                p[a][i]=c;
            }
            else{
                f[a][i]=f[a][i-1]*2+2+f[b][i-1];
                p[a][i]=b;
            }
        }
    }
    printf("%lld",f[1][n]);
}
Problem1022

#include<cmath>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<iostream>
#include<algorithm>
using namespace std;
int t,n,x,sg,a[11000];
bool bk;
int main(){
    scanf("%d",&t);
    while(t--){
        scanf("%d",&n);bk=false;
        for(int i=1;i<=n;i++){
            scanf("%d",&a[i]);
            if(a[i]!=1)bk=true;
        }
        if(bk==true)sg=0;
        else sg=1;
        for(int i=1;i<=n;i++){
            sg^=a[i];
        }
        if(sg==0)printf("Brother\n");
        else printf("John\n");
    }
}
Problem1024

#include<cmath>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<iostream>
#include<algorithm>
using namespace std;
int X,Y,K;
double dfs(double x,double y,int k){
    double ans=999999999.0,sum;
    if(k==1){
        return max(x,y)/min(x,y);
    }
    else{
        for(int i=1;i<k;i++){
            sum=0.0;
            sum=max(sum,dfs((x/k)*i,y,i));
            sum=max(sum,dfs(x-((x/k)*i),y,k-i));
            ans=min(sum,ans);
            sum=0.0;
            sum=max(sum,dfs(x,(y/k)*i,i));
            sum=max(sum,dfs(x,(y-(y/k)*i),k-i));
            ans=min(sum,ans);
        }
    }
    return ans;
}
int main(){
    scanf("%d%d%d",&X,&Y,&K);
    printf("%.6lf",dfs(X,Y,K));
}
Problem1026

#include<cmath>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<iostream>
#include<algorithm>
using namespace std;
int f[110][110],w[110],len,ax,ay,x,y;
int main(){
    for(int i=0;i<=9;i++)f[1][i]=1;
    for(int i=2;i<=15;i++){
        for(int j=0;j<=9;j++){
            for(int k=0;k<=9;k++){
                if(abs(j-k)>=2)f[i][j]+=f[i-1][k];
            } 
        }
    }
    ax=ay=0;
    scanf("%d%d",&x,&y);
    len=0;
    while(x>0){
        w[++len]=x%10;
        x/=10;
    }
    for(int i=1;i<len;i++){
        for(int j=1;j<=9;j++)ax+=f[i][j];
    }
    for(int i=1;i<w[len];i++)ax+=f[len][i];
    for(int i=len-1;i>=1;i--){
        for(int j=0;j<w[i];j++)if(abs(w[i+1]-j)>=2)ax+=f[i][j];
        if(abs(w[i]-w[i+1])<2)break;
    }
    len=0;y++;  
    while(y>0){
        w[++len]=y%10;
        y/=10;
    }
    for(int i=1;i<len;i++){
        for(int j=1;j<=9;j++)ay+=f[i][j];
    }
    for(int i=1;i<w[len];i++)ay+=f[len][i];
    for(int i=len-1;i>=1;i--){
        for(int j=0;j<w[i];j++)if(abs(w[i+1]-j)>=2)ay+=f[i][j];
        if(abs(w[i]-w[i+1])<2)break;
    }
    printf("%d\n",ay-ax);
}
Problem1029

#include<set>
#include<cmath>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<iostream>
#include<algorithm>
using namespace std;
multiset<int> x;
multiset<int>::iterator it;
struct node{
    int x,y;
}a[210000];
int n,ans,now,tmp,s;
int cmp(const void *xx,const void *yy){
    node n1=*(node*)xx;
    node n2=*(node*)yy;
    return n1.y-n2.y;
}
int main(){
    scanf("%d",&n);
    for(int i=1;i<=n;i++)scanf("%d%d",&a[i].x,&a[i].y);
    qsort(a+1,n,sizeof(node),cmp);
    for(int i=1;i<=n;i++){
        if(now+a[i].x<=a[i].y){
            ans++;
            now+=a[i].x;
            x.insert(a[i].x);
        }
        else{
            it=x.end();it--;
            tmp=*it;s=x.count(tmp);
            if(a[i].x<tmp){
                x.erase(tmp);
                for(int i=1;i<s;i++){
                    x.insert(tmp);
                }
                x.insert(a[i].x);
                now=now-tmp+a[i].x;
            }
        }
    }
    printf("%d\n",ans);
    return 0;
}
Problem1029

#include<queue>
#include<cmath>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<iostream>
#include<algorithm>
using namespace std;
priority_queue<int> x;
struct node{
    int x,y;
}a[210000];
int n,ans,now,tmp,s;
int cmp(const void *xx,const void *yy){
    node n1=*(node*)xx;
    node n2=*(node*)yy;
    return n1.y-n2.y;
}
int main(){
    scanf("%d",&n);
    for(int i=1;i<=n;i++)scanf("%d%d",&a[i].x,&a[i].y);
    qsort(a+1,n,sizeof(node),cmp);
    for(int i=1;i<=n;i++){
        if(now+a[i].x<=a[i].y){
            ans++;
            now+=a[i].x;
            x.push(a[i].x);
        }
        else{
            tmp=x.top();
            //printf("%d\n",tmp);
            if(a[i].x<tmp){
                x.pop();

                x.push(a[i].x);
                now=now-tmp+a[i].x;
            }
        }
    }
    printf("%d\n",ans);
    return 0;
}
Problem1034

#include<cmath>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<iostream>
#include<algorithm>
using namespace std;
int cmp(const void *xx,const void *yy){
    int n1=*(int *)xx;
    int n2=*(int *)yy;
    return n1-n2;
}
int n;
int a[110000],b[110000];
int solve(int a[],int b[]){
    int l=1,r=n,p=1,q=n,ans=0;
    while(l<=r && p<=q){
        if(a[l]>b[p]){ans+=2;l++;p++;}
        else if(a[r]>b[q]){ans+=2;r--;q--;}
        else {
            if(a[l]==b[q])ans+=1;
            l++;q--;
        }
    }
    return ans;
}
int main(){
    scanf("%d",&n);
    for(int i=1;i<=n;i++)scanf("%d",&a[i]);
    for(int i=1;i<=n;i++)scanf("%d",&b[i]);
    qsort(a+1,n,sizeof(int),cmp);
    qsort(b+1,n,sizeof(int),cmp);
    printf("%d %d\n",solve(a,b),2*n-solve(b,a));
}
Problem1036

#include<cmath>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<iostream>
#include<algorithm>
using namespace std;
struct node{
    int x,y,next;   
}a[2100000];int len,first[1100000];
void ins(int x,int y){
    len++;a[len].x=x;a[len].y=y;
    a[len].next=first[x];first[x]=len;  
}
struct tree{
    int l,r,lc,rc,c,s;  
}tr[2100000];int trlen;
void bt(int l,int r){
    trlen++;int now=trlen;
    tr[now].l=l;tr[now].r=r;tr[now].c=-99999999;tr[now].s=0; 
    tr[now].lc=tr[now].rc=-1;
    if(l<r){
        int mid=(l+r)/2;
        tr[now].lc=trlen+1;bt(l,mid);
        tr[now].rc=trlen+1;bt(mid+1,r);
    }
}
int tot[1100000],top[1100000],fa[1100000],dep[1100000],son[1100000],ys[1100000],n,z;
void pretree(int x){
    tot[x]=1;son[x]=0;
    for(int k=first[x];k>0;k=a[k].next){
        int y=a[k].y;
        if(y!=fa[x]){
            fa[y]=x;
            dep[y]=dep[x]+1;
            pretree(y);
            if(tot[son[x]]<tot[y])son[x]=y;
            tot[x]+=tot[y]; 
        }
    }
} 
void preedge(int x,int tp){
    ys[x]=++z;top[x]=tp;
    if(son[x]!=0)preedge(son[x],tp);
    for(int k=first[x];k>0;k=a[k].next){
        int y=a[k].y;
        if(y!=son[x]&&y!=fa[x]){
            preedge(y,y);       
        }
    }
}
void change(int now,int p,int c){
    if(tr[now].l==tr[now].r){tr[now].c=c;tr[now].s=c;return ;}
    int lc=tr[now].lc,rc=tr[now].rc,mid=(tr[now].l+tr[now].r)/2;
    if(p<=mid)change(lc,p,c);
    else change(rc,p,c);
    tr[now].c=max(tr[lc].c,tr[rc].c);
    tr[now].s=tr[lc].s+tr[rc].s;
}
int findmax(int now,int l,int r){
    if(tr[now].l==l&&tr[now].r==r)return tr[now].c;
    int lc=tr[now].lc,rc=tr[now].rc,mid=(tr[now].l+tr[now].r)/2;    
    if(mid+1<=l)return findmax(rc,l,r);
    else if(r<=mid)return findmax(lc,l,r);
    else return max(findmax(lc,l,mid),findmax(rc,mid+1,r));
}
int findsum(int now,int l,int r){
    if(tr[now].l==l&&tr[now].r==r)return tr[now].s;
    int lc=tr[now].lc,rc=tr[now].rc,mid=(tr[now].l+tr[now].r)/2;    
    if(mid+1<=l)return findsum(rc,l,r);
    else if(r<=mid)return findsum(lc,l,r);
    else return findsum(lc,l,mid)+findsum(rc,mid+1,r);
}
int c[110000];
int solve(int x,int y){
    int tx=top[x],ty=top[y],ans=-99999999;
    while(tx!=ty){
        if(dep[tx]>dep[ty]){
            swap(x,y);swap(tx,ty);
        }
        ans=max(ans,findmax(1,ys[ty],ys[y]));
        y=fa[ty];ty=top[y];
    }
    if(x==y)return max(c[x],ans);
    else{
        if(dep[x]>dep[y])swap(x,y);
        return max(ans,findmax(1,ys[x],ys[y])); 
    }
}
int getsum(int x,int y){
    int tx=top[x],ty=top[y];
    int ans=0;
    while(tx!=ty){
        if(dep[tx]>dep[ty]){
            swap(x,y);swap(tx,ty);
        }
        ans+=findsum(1,ys[ty],ys[y]);
        y=fa[ty];ty=top[y];
    }
    if(x==y)return c[x]+ans;
    else{
        if(dep[x]>dep[y])swap(x,y);
        return ans+findsum(1,ys[x],ys[y]);  
    }
}
struct bian{
    int x,y;      
}e[2100000];
int main(){
    scanf("%d",&n);
    len=0;memset(first,0,sizeof(first));
    for(int i=1;i<n;i++){
        scanf("%d%d",&e[i].x,&e[i].y);
        ins(e[i].x,e[i].y);ins(e[i].y,e[i].x);
    }
    dep[1]=0;fa[1]=0;pretree(1);
    z=0;preedge(1,1); 
    trlen=0;bt(1,z); 
    for(int i=1;i<n;i++)if(dep[e[i].x]>dep[e[i].y])swap(e[i].x,e[i].y);
    for(int i=1;i<=n;i++){
        scanf("%d",&c[i]);
        change(1,ys[i],c[i]);
    }   
    char ss[15];int x,y,t;
    scanf("%d",&t); 
    while(t--){
        scanf("%s%d%d",ss,&x,&y);
        if(ss[1]=='H'){c[x]=y;change(1,ys[x],y);}
        else if(ss[1]=='M')printf("%d\n",solve(x,y));
        else if(ss[1]=='S')printf("%d\n",getsum(x,y));
    }
    return 0;
}
/*
---输入--- 
4
1 2
2 3
4 1
4 2 1 3
12
QMAX 3 4
QMAX 3 3
QMAX 3 2
QMAX 2 3
QSUM 3 4
QSUM 2 1
CHANGE 1 5
QMAX 3 4
CHANGE 3 6
QMAX 3 4
QMAX 2 4
QSUM 3 4
---输出--- 
4
1
2
2
10
6
5
6
5
16



5
1 4
2 3
1 5
2 4
5 -1 2 1 3
10
QMAX 1 3
5
QSUM 2 4
0
QMAX 2 1
5
CHANGE 2 5
QMAX 1 5
5
CHANGE 2 0
QMAX 1 2
5
QSUM 1 3
8
CHANGE 1 11
QMAX 1 5
11
*/
Problem1036

#include<cmath>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<iostream>
#include<algorithm>
using namespace std;
struct node{
    int x,y,next;   
}a[2100000];int len,first[1100000];
void ins(int x,int y){
    len++;a[len].x=x;a[len].y=y;
    a[len].next=first[x];first[x]=len;  
}
struct tree{
    int l,r,lc,rc,c,s;  
}tr[2100000];int trlen;
void bt(int l,int r){
    trlen++;int now=trlen;
    tr[now].l=l;tr[now].r=r;tr[now].c=-99999999;tr[now].s=0; 
    tr[now].lc=tr[now].rc=-1;
    if(l<r){
        int mid=(l+r)/2;
        tr[now].lc=trlen+1;bt(l,mid);
        tr[now].rc=trlen+1;bt(mid+1,r);
    }
}
int tot[1100000],top[1100000],fa[1100000],dep[1100000],son[1100000],ys[1100000],n,z;
void pretree(int x){
    tot[x]=1;son[x]=0;
    for(int k=first[x];k>0;k=a[k].next){
        int y=a[k].y;
        if(y!=fa[x]){
            fa[y]=x;
            dep[y]=dep[x]+1;
            pretree(y);
            if(tot[son[x]]<tot[y])son[x]=y;
            tot[x]+=tot[y]; 
        }
    }
} 
void preedge(int x,int tp){
    ys[x]=++z;top[x]=tp;
    if(son[x]!=0)preedge(son[x],tp);
    for(int k=first[x];k>0;k=a[k].next){
        int y=a[k].y;
        if(y!=son[x]&&y!=fa[x]){
            preedge(y,y);       
        }
    }
}
void change(int now,int p,int c){
    if(tr[now].l==tr[now].r){tr[now].c=c;tr[now].s=c;return ;}
    int lc=tr[now].lc,rc=tr[now].rc,mid=(tr[now].l+tr[now].r)/2;
    if(p<=mid)change(lc,p,c);
    else change(rc,p,c);
    tr[now].c=max(tr[lc].c,tr[rc].c);
    tr[now].s=tr[lc].s+tr[rc].s;
}
int findmax(int now,int l,int r){
    if(tr[now].l==l&&tr[now].r==r)return tr[now].c;
    int lc=tr[now].lc,rc=tr[now].rc,mid=(tr[now].l+tr[now].r)/2;    
    if(mid+1<=l)return findmax(rc,l,r);
    else if(r<=mid)return findmax(lc,l,r);
    else return max(findmax(lc,l,mid),findmax(rc,mid+1,r));
}
int findsum(int now,int l,int r){
    if(tr[now].l==l&&tr[now].r==r)return tr[now].s;
    int lc=tr[now].lc,rc=tr[now].rc,mid=(tr[now].l+tr[now].r)/2;    
    if(mid+1<=l)return findsum(rc,l,r);
    else if(r<=mid)return findsum(lc,l,r);
    else return findsum(lc,l,mid)+findsum(rc,mid+1,r);
}
int c[110000];
int solve(int x,int y){
    int tx=top[x],ty=top[y],ans=-99999999;
    while(tx!=ty){
        if(dep[tx]>dep[ty]){
            swap(x,y);swap(tx,ty);
        }
        ans=max(ans,findmax(1,ys[ty],ys[y]));
        y=fa[ty];ty=top[y];
    }
    if(x==y)return max(c[x],ans);
    else{
        if(dep[x]>dep[y])swap(x,y);
        return max(ans,findmax(1,ys[x],ys[y])); 
    }
}
int getsum(int x,int y){
    int tx=top[x],ty=top[y];
    int ans=0;
    while(tx!=ty){
        if(dep[tx]>dep[ty]){
            swap(x,y);swap(tx,ty);
        }
        ans+=findsum(1,ys[ty],ys[y]);
        y=fa[ty];ty=top[y];
    }
    if(x==y)return c[x]+ans;
    else{
        if(dep[x]>dep[y])swap(x,y);
        return ans+findsum(1,ys[x],ys[y]);  
    }
}
struct bian{
    int x,y;      
}e[2100000];
int main(){
    scanf("%d",&n);
    len=0;memset(first,0,sizeof(first));
    for(int i=1;i<n;i++){
        scanf("%d%d",&e[i].x,&e[i].y);
        ins(e[i].x,e[i].y);ins(e[i].y,e[i].x);
    }
    dep[1]=0;fa[1]=0;pretree(1);
    z=0;preedge(1,1); 
    trlen=0;bt(1,z); 
    for(int i=1;i<=n;i++){
        scanf("%d",&c[i]);
        change(1,ys[i],c[i]);
    }   
    char ss[15];int x,y,t;
    scanf("%d",&t); 
    while(t--){
        scanf("%s%d%d",ss,&x,&y);
        if(ss[1]=='H'){c[x]=y;change(1,ys[x],y);}
        else if(ss[1]=='M')printf("%d\n",solve(x,y));
        else if(ss[1]=='S')printf("%d\n",getsum(x,y));
    }
    return 0;
}
/*
---输入--- 
4
1 2
2 3
4 1
4 2 1 3
12
QMAX 3 4
QMAX 3 3
QMAX 3 2
QMAX 2 3
QSUM 3 4
QSUM 2 1
CHANGE 1 5
QMAX 3 4
CHANGE 3 6
QMAX 3 4
QMAX 2 4
QSUM 3 4
---输出--- 
4
1
2
2
10
6
5
6
5
16
--- 题解---
默默无闻
多了一句
if(x>y)swap(x,y);
change的时候把2改成1
就变成1改成2 
*/
Problem1036

#include<cmath>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<iostream>
#include<algorithm>
using namespace std;
struct node{
    int x,y,next;   
}a[2100000];int len,first[1100000];
void ins(int x,int y){
    len++;a[len].x=x;a[len].y=y;
    a[len].next=first[x];first[x]=len;  
}
struct tree{
    int l,r,lc,rc,c,s;  
}tr[2100000];int trlen;
void bt(int l,int r){
    trlen++;int now=trlen;
    tr[now].l=l;tr[now].r=r;tr[now].c=-99999999;tr[now].s=0; 
    tr[now].lc=tr[now].rc=-1;
    if(l<r){
        int mid=(l+r)/2;
        tr[now].lc=trlen+1;bt(l,mid);
        tr[now].rc=trlen+1;bt(mid+1,r);
    }
}
int tot[1100000],top[1100000],fa[1100000],dep[1100000],son[1100000],ys[1100000],n,z;
void pretree(int x){
    tot[x]=1;son[x]=0;
    for(int k=first[x];k>0;k=a[k].next){
        int y=a[k].y;
        if(y!=fa[x]){
            fa[y]=x;
            dep[y]=dep[x]+1;
            pretree(y);
            if(tot[son[x]]<tot[y])son[x]=y;
            tot[x]+=tot[y]; 
        }
    }
} 
void preedge(int x,int tp){
    ys[x]=++z;top[x]=tp;
    if(son[x]!=0)preedge(son[x],tp);
    for(int k=first[x];k>0;k=a[k].next){
        int y=a[k].y;
        if(y!=son[x]&&y!=fa[x]){
            preedge(y,y);       
        }
    }
}
void change(int now,int p,int c){
    if(tr[now].l==tr[now].r){tr[now].c=c;tr[now].s=c;return ;}
    int lc=tr[now].lc,rc=tr[now].rc,mid=(tr[now].l+tr[now].r)/2;
    if(p<=mid)change(lc,p,c);
    else change(rc,p,c);
    tr[now].c=max(tr[lc].c,tr[rc].c);
    tr[now].s=tr[lc].s+tr[rc].s;
}
int findmax(int now,int l,int r){
    if(tr[now].l==l&&tr[now].r==r)return tr[now].c;
    int lc=tr[now].lc,rc=tr[now].rc,mid=(tr[now].l+tr[now].r)/2;    
    if(mid+1<=l)return findmax(rc,l,r);
    else if(r<=mid)return findmax(lc,l,r);
    else return max(findmax(lc,l,mid),findmax(rc,mid+1,r));
}
int findsum(int now,int l,int r){
    if(tr[now].l==l&&tr[now].r==r)return tr[now].s;
    int lc=tr[now].lc,rc=tr[now].rc,mid=(tr[now].l+tr[now].r)/2;    
    if(mid+1<=l)return findsum(rc,l,r);
    else if(r<=mid)return findsum(lc,l,r);
    else return findsum(lc,l,mid)+findsum(rc,mid+1,r);
}
int c[110000];
int solve(int x,int y){
    int tx=top[x],ty=top[y],ans=-99999999;
    while(tx!=ty){
        if(dep[tx]>dep[ty]){
            swap(x,y);swap(tx,ty);
        }
        ans=max(ans,findmax(1,ys[ty],ys[y]));
        y=fa[ty];ty=top[y];
    }
    if(x==y)return max(c[x],ans);
    else{
        if(dep[x]>dep[y])swap(x,y);
        return max(ans,findmax(1,ys[x],ys[y])); 
    }
}
int getsum(int x,int y){
    int tx=top[x],ty=top[y],ans=0;
    while(tx!=ty){
        if(dep[tx]>dep[ty]){
            swap(x,y);swap(tx,ty);
        }
        ans+=findsum(1,ys[ty],ys[y]);
        y=fa[ty];ty=top[y];
    }
    if(x==y)return c[x]+ans;
    else{
        if(dep[x]>dep[y])swap(x,y);
        return ans+findsum(1,ys[x],ys[y]);  
    }
}
struct bian{
    int x,y;      
}e[2100000];
int main(){
    scanf("%d",&n);
    len=0;memset(first,0,sizeof(first));
    for(int i=1;i<n;i++){
        scanf("%d%d",&e[i].x,&e[i].y);
        ins(e[i].x,e[i].y);ins(e[i].y,e[i].x);
    }
    dep[1]=0;fa[1]=0;pretree(1);
    z=0;preedge(1,1); 
    trlen=0;bt(1,z); 
    for(int i=1;i<=n;i++){
        scanf("%d",&c[i]);
        change(1,ys[i],c[i]);
    }   
    char ss[15];int x,y,t;
    scanf("%d",&t); 
    while(t--){
        scanf("%s%d%d",ss,&x,&y);
        if(ss[1]=='H'){c[x]=y;change(1,ys[x],y);}
        else if(ss[1]=='M')printf("%d\n",solve(x,y));
        else if(ss[1]=='S')printf("%d\n",getsum(x,y));
    }
    return 0;
}
/*
---输入--- 
4
1 2
2 3
4 1
4 2 1 3
12
QMAX 3 4
QMAX 3 3
QMAX 3 2
QMAX 2 3
QSUM 3 4
QSUM 2 1
CHANGE 1 5
QMAX 3 4
CHANGE 3 6
QMAX 3 4
QMAX 2 4
QSUM 3 4
---输出--- 
4
1
2
2
10
6
5
6
5
16
--- 题解---
默默无闻
多了一句
if(x>y)swap(x,y);
change的时候把2改成1
就变成1改成2 
*/
Problem1037

#include<cmath>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<iostream>
#include<algorithm>
using namespace std;
const int mod=12345678;
int n,m,k,ans,f[301][151][21][21];
int main(){
    scanf("%d%d%d",&n,&m,&k);
    f[0][0][0][0]=1;
    for(int i=0;i<n+m;i++){
        for(int j=0;j<=n;j++){
            for(int x=0;x<=k;x++){
                for(int y=0;y<=k;y++){
                    if(f[i][j][x][y]){
                        if(x+1<=k&&j+1<=n){
                            f[i+1][j+1][x+1][max(y-1,0)]+=f[i][j][x][y];
                            f[i+1][j+1][x+1][max(y-1,0)]%=mod;
                        }
                        if(y+1<=k&&i+1-j<=m){
                            f[i+1][j][max(x-1,0)][y+1]+=f[i][j][x][y];
                            f[i+1][j][max(x-1,0)][y+1]%=mod;
                        }
                    }
                }
            }
        }
    }
    ans=0;
    for(int i=0;i<=n;i++){
        for(int x=0;x<=k;x++){
            for(int y=0;y<=k;y++){
                ans+=f[n+m][i][x][y];
                ans%=mod;
            }
        }
    }
    printf("%d\n",ans);
    return 0;
}
Problem1041

#include<cstdio>
#include<iostream>
#include<cmath>
using namespace std;
long long R,ans;
long long gcd(long long x,long long y){return x%y==0? y:gcd(y,x%y);}
bool check(long long y,double x)
{
      if(x==floor(x))
      {
            long long x1=(long long)floor(x);
            if(gcd(x1*x1,y*y)==1&&x1*x1!=y*y)
                  return true;
      }
      return false;
}
int main()
{
      scanf("%lld",&R);
      for(long long d=1;d<=sqrt(2*R);d++)
      {
            if((2*R)%d==0)
            {
                  for(long long a=1;a<=(long long)sqrt(2*R/(2*d));a++)
                  {
                        double b=sqrt(((2*R)/d)-a*a);
                        if(check(a,b))ans++;
                  }
                  if(d!=(2*R)/d)
                  {
                        for(long long a=1;a<=(long long)sqrt(d/2);a++)
                        {
                              double b=sqrt(d-a*a);
                              if(check(a,b))
                                    ans++;
                        }
                  }
            }
      }    
      printf("%lld",ans*4+4); 
      return 0;
}
Problem1042

#include<cmath>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<iostream>
#include<algorithm>
typedef long long LL;
using namespace std;
LL ans,f[110000],N,c[5],d[5],s;
void dfs(LL x,LL k,LL sum){
    if(sum<0)return;
    if(x==5){
        if(k%2==1)ans-=f[sum];
        else ans+=f[sum];
        return ;
    }
    dfs(x+1,k+1,sum-(d[x]+1)*c[x]);
    dfs(x+1,k,sum);
}
int main(){
    for(int i=1;i<=4;i++)scanf("%lld",&c[i]);scanf("%lld",&N);
    memset(f,0,sizeof(f));f[0]=1;
    for(int i=1;i<=4;i++){
        for(int j=c[i];j<=100000;j++){
            f[j]+=f[j-c[i]];
        }
    }
    while(N--){
        for(int i=1;i<=4;i++)scanf("%lld",&d[i]);scanf("%lld",&s);
        ans=0;
        dfs(1,0,s);
        printf("%lld\n",ans);
    }
    return 0;
}
Problem1050

#include<cmath>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<iostream>
#include<algorithm>
using namespace std;
struct edge{
    int x,y,d;
}e[11000];
int maxx,minn,fx,fy,tmp,j;
bool cmp(edge n1,edge n2){
    return n1.d<n2.d;
}
int n,m,st,ed,fa[11000];
int gcd(int a,int b){//最小公倍 
    if(a==0)return b;
    else return gcd(b%a,a);
}
int findfa(int x){
    if(fa[x]!=x)fa[x]=findfa(fa[x]);//判断联通 
    return fa[x];
}
int main(){
    scanf("%d%d",&n,&m);
    for(int i=1;i<=m;i++){
        scanf("%d%d%d",&e[i].x,&e[i].y,&e[i].d);
    }
    scanf("%d%d",&st,&ed);
    sort(e+1,e+m+1,cmp);//小到大排序 
    minn=0;maxx=30000;
    for(int i=1;i<=m;i++){//一条一条舍弃小的边 
        for(j=1;j<=n;j++)fa[j]=j;//自己单独一块 
        for(j=i;j<=m;j++){
            fx=findfa(e[j].x);fy=findfa(e[j].y);//判断联通 
            fa[fx]=fy;
            if(findfa(st)==findfa(ed))break;//如果联通；了就退出 
        }
        if(fa[st]!=fa[ed])break;//如果fa就是祖先不同就是 不联通直接跳出，现在就是最优的啦 
        if(maxx*e[i].d>e[j].d*minn){//更新啦！！！ 
            maxx=e[j].d;minn=e[i].d;    
        }
    }
    if(maxx==30000)printf("IMPOSSIBLE\n");//输出不说了 
    else{
        if(maxx%minn==0)printf("%d\n",maxx/minn);
        else{
            tmp=gcd(maxx,minn);
            printf("%d/%d\n",maxx/tmp,minn/tmp);
        }
    }
}
Problem1050

#include<cmath>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<iostream>
#include<algorithm>
using namespace std;
struct node{
    int x,y,d;
}e[11000];
int maxx,minn,fx,fy,tmp,j,n,m,st,ed,fa[11000];
bool cmp(node n1,node n2){
    return n1.d<n2.d;
}
int gcd(int a,int b){ 
    if(a==0)return b;
    else return gcd(b%a,a);
}
int findfa(int x){
    if(fa[x]!=x)fa[x]=findfa(fa[x]); 
    return fa[x];
}
int main(){
    scanf("%d%d",&n,&m);
    for(int i=1;i<=m;i++)scanf("%d%d%d",&e[i].x,&e[i].y,&e[i].d); 
    scanf("%d%d",&st,&ed);
    sort(e+1,e+m+1,cmp); 
    minn=0;maxx=300000;
    for(int i=1;i<=m;i++){ 
        for(j=1;j<=n;j++)fa[j]=j; 
        for(j=i;j<=m;j++){
            fx=findfa(e[j].x);fy=findfa(e[j].y); 
            fa[fx]=fy;
            if(findfa(st)==findfa(ed))break; 
        }
        if(fa[st]!=fa[ed])break; 
        if(maxx*e[i].d>e[j].d*minn){ 
            maxx=e[j].d;minn=e[i].d;    
        }
    }
    if(maxx==300000)printf("IMPOSSIBLE\n"); 
    else{
        if(maxx%minn==0)printf("%d\n",maxx/minn);
        else{
            tmp=gcd(maxx,minn);
            printf("%d/%d\n",maxx/tmp,minn/tmp);
        }
    }
} 
Problem1051

#include<set>
#include<map>
#include<cmath>
#include<cstdio>
#include<vector>
#include<cstring>
#include<cstdlib>
#include<iostream>
#include<algorithm>
using namespace std;
struct node{
    int x,y,next;
}a[110000];int len,first[11000],n,m;
void ins(int x,int y){
    len++;a[len].x=x;a[len].y=y;
    a[len].next=first[x];first[x]=len;
}
int sta[11000],tp;bool v[11000];
int cnt,belong[11000];
int low[11000],dfn[11000],id,num[11000];
int chu[11000],ru[11000];
void dfs(int x){
    low[x]=dfn[x]=++id;
    sta[++tp]=x;v[x]=true;
    for(int k=first[x];k>0;k=a[k].next){
        int y=a[k].y;
        if(dfn[y]==0){
            dfs(y);
            if(low[x]>low[y])low[x]=low[y];
        }
        else if(v[y]==true){
            if(low[x]>dfn[y])low[x]=dfn[y];
        }
    }
    if(low[x]==dfn[x]){
        cnt++;
        int i;
        do{ 
            i=sta[tp--];
            belong[i]=cnt; 
            v[i]=false;
        }while(i!=x);
    }
}
int main(){
    scanf("%d%d",&n,&m);
    len=0;memset(first,false,sizeof(first));
    cnt=0;memset(v,false,sizeof(v)); 
    memset(dfn,0,sizeof(dfn));
    tp=id=cnt=0;
    for(int i=1;i<=m;i++){
        int x,y;
        scanf("%d%d",&x,&y);
        ins(x,y);
    }
    for(int i=1;i<=n;i++)if(dfn[i]==0)dfs(i);
    memset(num,0,sizeof(num));
    for(int i=1;i<=n;i++)num[belong[i]]++;
    for(int i=1;i<=len;i++){
        if(belong[a[i].x]!=belong[a[i].y]){
            chu[belong[a[i].x]]++;
            ru[belong[a[i].y]]++;
        }
    }
    if(cnt==1){printf("%d\n",n);return 0;}
    int ans,zs=0;
    for(int i=1;i<=cnt;i++){
        if(chu[i]==0){
            zs++;ans=i;
        }
    }
    if(zs==1)printf("%d\n",num[ans]);
    else printf("0\n");
}
Problem1053

#include<cmath>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<iostream>
#include<algorithm>
using namespace std;
int n,ans=1,num=1;
int p[20]={1,2,3,5,7,11,13,17,19,23,29,31};
void dfs(int k,long long now,int cnt,int tt){
    if(k==12){
        if(now>ans&&cnt>num){
            ans=now;num=cnt;
        }
        if(now<=ans&&cnt>=num){
            ans=now;num=cnt;
        }
        return;
    }
    int tmp=1;
    for(int i=0;i<=tt;i++){
        dfs(k+1,now*tmp,cnt*(i+1),i);
        tmp*=p[k];
        if(now*tmp>n)break;
    }
}
int main(){
    scanf("%d",&n);
    dfs(1,1,1,20);
    printf("%d\n",ans);
    return 0;
}
Problem1059

#include<set>
#include<map>
#include<cmath>
#include<cstdio>
#include<vector>
#include<cstring>
#include<cstdlib>
#include<iostream>
#include<algorithm>
using namespace std;
int match[1100],n,m,ans,tmp,xx;
bool a[1100][1100],w[1100];
bool findmuniu(int x){
    for(int j=1;j<=n;j++){
        if(a[x][j]==true){
            if(w[j]==false){
                w[j]=true; 
                if(match[j]==0||findmuniu(match[j])==true){
                    match[j]=x;
                    return true;
                }
            }
        }
    }
    return false;
}
int main(){
    int t;
    scanf("%d",&t);
    while(t--){
        scanf("%d",&n);
        for(int i=1;i<=n;i++){
            for(int j=1;j<=n;j++){
                scanf("%d",&a[i][j]);
            }
        }
        ans=0;
        memset(match,0,sizeof(match));
        for(int i=1;i<=n;i++){
            memset(w,false,sizeof(w));
            if(findmuniu(i)==true)ans++;
        }
        if(ans>=n)printf("Yes\n");
        else printf("No\n");
    }   
    return 0;
}
Problem1061

#include<set>
#include<map>
#include<cmath>
#include<cstdio>
#include<vector>
#include<cstring>
#include<cstdlib>
#include<iostream>
#include<algorithm>
using namespace std;
struct node{
    int x,y,c,d,next,other;
}a[5100000];int len,first[110000];
int st,ed,n,m,ans;
void ins(int x,int y,int c,int d){
    int k1,k2;
    len++;k1=len;
    a[len].x=x;a[len].y=y;a[len].c=c;a[len].d=d;
    a[len].next=first[x];first[x]=len;
    len++;k2=len;
    a[len].x=y;a[len].y=x;a[len].c=0;a[len].d=-d;
    a[len].next=first[y];first[y]=len;
    a[k1].other=k2;
    a[k2].other=k1; 
}
int pre[110000],d[110000],list[110000],head,tail,da[110000],c[110000];
bool v[110000];
bool spfa(){
    memset(d,0x3F,sizeof(d));d[st]=0;
    memset(v,true,sizeof(v));v[st]=false;
    memset(c,0,sizeof(c));c[st]=99999999;
    list[1]=st;head=1;tail=2;
    while(head!=tail){
        int x=list[head];
        for(int k=first[x];k>0;k=a[k].next){
            int y=a[k].y;
            if(a[k].c>0&&d[y]>d[x]+a[k].d){
                d[y]=d[x]+a[k].d;
                c[y]=min(c[x],a[k].c);
                pre[y]=k;
                if(v[y]==true){
                    v[y]=false;
                    list[tail++]=y;
                    if(tail==ed+1)tail=0;
                }
            }
        }
        head++;if(head==ed+1)head=0;
        v[x]=true;
    }
    if(d[ed]>100000000)return false;
    int x=ed;
    while(x!=st){
        int k=pre[x];
        a[k].c-=c[ed];a[a[k].other].c+=c[ed];
        ans+=a[k].d*c[ed];
        x=a[k].x;
    }
    return true;
}
int main(){
    scanf("%d%d",&n,&m);
    st=0,ed=n+2;
    len=0;memset(first,0,sizeof(first));
    for(int i=1;i<=n;i++)scanf("%d",&da[i]);da[n+1]=da[0]=0;
    for(int i=1;i<=m;i++){ 
        int aa,bb,cc,k;
        scanf("%d%d%d",&aa,&bb,&cc);
        if(aa>bb)swap(aa,bb);
        ins(bb+1,aa,99999999,cc);
    }
    for(int i=1;i<=n+1;i++){
        int aa,bb,cc,k;
        if(da[i]>da[i-1])ins(i,ed,da[i]-da[i-1],0);
        else ins(st,i,da[i-1]-da[i],0);
        if(i<=n)ins(i,i+1,999999999,0); 
    }
    ans=0;while(spfa());  
    printf("%d\n",ans);
} 
Problem1066

#include<cmath>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<iostream>
#include<algorithm>
using namespace std;
struct node{
    int x,y,c,next,other;
}a[1100000];int len,first[1100000];
int n,m,d,list[1100000],head,tail,st,ed,K[1100][1100],ans,answer,h[1100000],Nh[1100][1100],Ch[1100][1100];
char s[1100];
double pd(int x,int y,int x1,int y1){
    return sqrt(double((x-x1)*(x-x1)+(y-y1)*(y-y1)));
}
void ins(int x,int y,int c){
    int xx,yy;
    len++;xx=len;
    a[len].x=x;a[len].y=y;a[len].c=c;
    a[len].next=first[x];first[x]=len;
    len++;yy=len;
    a[len].x=y;a[len].y=x;a[len].c=0;
    a[len].next=first[y];first[y]=len;
    a[xx].other=yy;
    a[yy].other=xx;
}
bool bt(){
    memset(h,0,sizeof(h));h[st]=1;
    list[1]=st;head=1;tail=2;
    while(head!=tail){
        int x=list[head];
        for(int k=first[x];k>0;k=a[k].next){
            int y=a[k].y;
            if(a[k].c>0&&h[y]==0){
                h[y]=h[x]+1;
                list[tail++]=y;
            }
        }
        head++;
    }
    if(h[ed]>0)return true;
    else return false;
}
int findflow(int x,int f){
    if(x==ed)return f;
    int s=0,tmp;
    for(int k=first[x];k>0;k=a[k].next){
        int y=a[k].y;
        if(a[k].c>0&&h[y]==h[x]+1&&s<f){
            tmp=findflow(y,min(a[k].c,f-s));
            s+=tmp;
            a[k].c-=tmp;a[a[k].other].c+=tmp;
        }
    }
    if(s==0)h[x]=0;
    return s;
}
int main(){
    scanf("%d%d%d",&n,&m,&d);
    st=0;ed=10001;
    len=0;memset(first,0,sizeof(first));
    for(int i=1;i<=n;i++){
        scanf("%s",s+1);
        for(int j=1;j<=m;j++){
            K[i][j]=s[j]-'0';
            Nh[i][j]=(m*(i-1)+j);
        }
    }
    for(int i=1;i<=n;i++){
        for(int j=1;j<=m;j++){
            Ch[i][j]=Nh[i][j]+n*m;
            if(K[i][j]>0)ins(Nh[i][j],Ch[i][j],K[i][j]);
        }
    }
    for(int i=1;i<=n;i++){
        for(int j=1;j<=m;j++){
            if(i<=d||j<=d||i>=n-d+1||j>=m-d+1){
                ins(Ch[i][j],ed,999999999);
            }
        }
    }
    answer=0;
    for(int i=1;i<=n;i++){
        scanf("%s",s+1);
        for(int j=1;j<=m;j++){
            if(s[j]=='L'){
                answer++;ins(st,Nh[i][j],1);
            }
        } 
    }
    for(int i=1;i<=n;i++){
        for(int j=1;j<=m;j++){
            int n1,n2,n3,n4;
            n1=max(i-d,1);n2=min(i+d,n);
            n3=max(j-d,1);n4=min(j+d,m);
            for(int x=n1;x<=n2;x++){
                for(int y=n3;y<=n4;y++){
                    if(pd(i,j,x,y)<=d){
                        if(x!=i||y!=j){
                            ins(Ch[i][j],Nh[x][y],999999999);
                        }
                    }
                }
            }
        }
    }
    ans=0;
    while(bt()==true){
        ans+=findflow(st,999999999);
    }
    printf("%d\n",answer-ans);
    return 0;
}

Problem1070

#include<cmath>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<iostream>
#include<algorithm>
using namespace std;
struct node{
    int x,y,c,d,other,next;
}a[210000];int len,first[210000];
void ins(int x,int y,int c,int d){
    int kx,ky;
    len++;kx=len;
    a[len].x=x;a[len].y=y;a[len].c=c;a[len].d=d;
    a[len].next=first[x];first[x]=len;
    len++;ky=len;
    a[len].x=y;a[len].y=x;a[len].c=0;a[len].d=-d;
    a[len].next=first[y];first[y]=len;         
    a[kx].other=ky;a[ky].other=kx;
}
int list[110000],d[110000],c[110000],pre[110000],head,tail,st,ed,n,m,xx,ans;
bool v[110000];
bool spfa(){
    memset(c,0,sizeof(c));c[st]=999999999;
    memset(v,false,sizeof(v));v[st]=true;
    memset(d,0x3F,sizeof(d));d[st]=0;
    list[1]=st;head=1;tail=2;pre[st]=0;
    while(head!=tail){
        int x=list[head];
        for(int k=first[x];k>0;k=a[k].next){
            int y=a[k].y;
            if(a[k].c>0&&d[y]>d[x]+a[k].d){
                d[y]=d[x]+a[k].d;
                c[y]=min(c[x],a[k].c);
                pre[y]=k;
                if(v[y]==false){
                    v[y]=true;
                    list[tail++]=y;
                    if(tail==ed+1)tail=1;
                }   
            }
        }
        head++;if(head==ed+1)head=1;
        v[x]=false;
    }
    if(d[ed]>999999999)return false;
    ans+=d[ed]*c[ed];
    int x=ed;
    while(x!=st){
        int k=pre[x];
        a[k].c-=c[ed];a[a[k].other].c+=c[ed];
        x=a[k].x;
    }
    return true;
}
int map[1100][1100];
int main(){
    scanf("%d%d",&m,&n);
    st=n*m+n+1;ed=n*m+n+2;
    len=0;memset(first,0,sizeof(first));
    for(int i=1;i<=n;i++){
        for(int j=1;j<=m;j++){
            scanf("%d",&map[i][j]);
        }
    }
    for(int i=1;i<=n;i++)ins(st,i,1,0);
    for(int i=n+1;i<=n+n*m;i++)ins(i,ed,1,0);
    for(int i=1;i<=n;i++){
        for(int j=1;j<=m;j++){
            for(int k=1;k<=n;k++){
                ins(i,j*n+k,1,map[i][j]*(n-k+1));
            }
        }
    }
    ans=0;
    while(spfa()==true);
    printf("%.2lf\n",double(ans)/double(n));
    return 0;
}
Problem1071

#include<cmath>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<iostream>
#include<algorithm>
using namespace std;
typedef long long LL;
struct node{
    LL x,y,sum;
}a[51000],b[51000];
LL A,B,C,ans;
int n;
int cmpx(const void *xx,const void *yy){
    node n1=*(node*)xx;
    node n2=*(node*)yy;
    return n1.x-n2.x;
}
int cmpsum(const void *xx,const void *yy){
    node n1=*(node*)xx;
    node n2=*(node*)yy;
    return n1.sum-n2.sum;
}
typedef long long LL;
int main(){
    int n;scanf("%d%lld%lld%lld",&n,&A,&B,&C);
    for(int i=1;i<=n;i++){
        scanf("%lld%lld",&a[i].x,&a[i].y);
        a[i].sum=A*a[i].x+B*a[i].y;
        b[i]=a[i];
    }
    qsort(a+1,n,sizeof(node),cmpx);
    qsort(b+1,n,sizeof(node),cmpsum);
    int ans=0;
    for(int i=1;i<=n;i++){
        LL low2=a[i].y,high=low2+C/B,l=0,r=0;
        int sum=0;
        for(int j=1;j<=n;j++){
            LL low1=a[j].x;
            while(r<n&&b[r+1].sum<=A*low1+B*low2+C){
                r++;if(b[r].y<=high&&b[r].y>=low2)sum++;
            }
            while(l<n&&a[l+1].x<low1){
                l++;if(a[l].y<=high&&a[l].y>=low2)sum--;
            }
            ans=max(ans,sum);
        }
    }
    printf("%d\n",ans);
    return 0;
}
Problem1081

#include<cmath>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<iostream>
#include<algorithm>
using namespace std;
int a[11000],n,B;
void dfs(int k,int t){
    if(k==n+1){
        for(int i=n;i>=1;i--){
            if(a[i]<10)printf("%d",a[i]);
            else printf("%c",a[i]+'A'-10);
        }
        printf("\n");
        return ;
    }
    if(t==0){
        for(int i=0;i<B;i++){
            a[k]=i;
            if(i%2==1)dfs(k+1,1);
            else dfs(k+1,0);
        }
    }
    else{
        for(int i=B-1;i>=0;i--){
            a[k]=i;
            if(i%2==1)dfs(k+1,0);
            else dfs(k+1,1);
        }
    }
}
int main(){
    scanf("%d%d",&n,&B);
    dfs(1,0);
}
Problem1082

#include<cmath>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<iostream>
#include<algorithm>
using namespace std;
int n,m,l,r,mid,ans,d,sum;
int a[11000],b[11000],v[10100];
bool dfs(int k,int t){
    if(k==0)return true;
    if(d+v[mid]>sum)return false;
    bool bk;
    for(int i=t;i<=m;i++){
        if(b[i]>=a[k]){
            b[i]-=a[k];
            if(b[i]<a[1])d+=b[i];
            if(a[k-1]==a[k])bk=dfs(k-1,i);
            else bk=dfs(k-1,1);
            if(b[i]<a[1])d-=b[i];
            b[i]+=a[k];
            if(bk==true)return true;
        }
    }
    return false;
}
int main(){
    sum=0;
    scanf("%d",&m);
    for(int i=1;i<=m;i++){
        scanf("%d",&b[i]);sum+=b[i];
    }
    scanf("%d",&n);
    for(int i=1;i<=n;i++)scanf("%d",&a[i]);
    sort(a+1,a+n+1);sort(b+1,b+m+1);
    v[0]=0;for(int i=1;i<=n;i++)v[i]=v[i-1]+a[i];
    while(v[n]>sum)n--;
    l=1;r=n;ans=0;d=0;
    while(l<=r){
        mid=(l+r)/2;
        if(dfs(mid,1)==true){
            l=mid+1;ans=mid;
        }
        else r=mid-1;
    }
    printf("%d\n",ans);
    return 0;
}
Problem1083

#include<cmath>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<iostream>
#include<algorithm>
using namespace std;
int n,m,fa[11000],len,maxx,fx,fy,ans;
int findfa(int x){
    if(fa[x]!=x)fa[x]=findfa(fa[x]);
    return fa[x];
}
struct edge{
    int x,y,d;
}e[11000];
int cmp(const void *xx,const void *yy){
    edge n1=*(edge *)xx;
    edge n2=*(edge *)yy;
    return n1.d-n2.d;
}
int main(){
    scanf("%d%d",&n,&m); 
    for(int i=1;i<=m;i++)scanf("%d%d%d",&e[i].x,&e[i].y,&e[i].d);
    qsort(e+1,m,sizeof(edge),cmp);
    for(int i=1;i<=n;i++)fa[i]=i;
    ans=0;
    for(int i=1;i<=m;i++){
        fx=findfa(e[i].x);fy=findfa(e[i].y);
        if(fx!=fy){
            fa[fx]=fy;
            ans++;
            if(ans==n-1){
                maxx=e[i].d; 
                break;
            }
        }
    }
    printf("%d %d\n",ans,maxx);
}
Problem1084

#include<cmath>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<iostream>
#include<algorithm>
using namespace std;
int n,m,K,a[110][20],f[110][110][20],sum[110][20];
int main(){
    scanf("%d%d%d",&n,&m,&K);
    memset(sum[0],0,sizeof(sum[0])); 
    for(int i=1;i<=n;i++){
        for(int j=1;j<=m;j++){
            scanf("%d",&a[i][j]);
            sum[i][j]=sum[i-1][j]+a[i][j];
        }
    }
    memset(f,0,sizeof(f));
    if(m==1){
        f[1][1][1]=a[1][1];
        for(int i=1;i<=n;i++){
            for(int k=1;k<=K;k++){
                f[i][1][k]=f[i-1][1][k];
                for(int j=i-1;j>=k-1;j--){
                    f[i][1][k]=max(f[i][1][k],(sum[i][1]-sum[j][1])+f[j][1][k-1]);
                }
            }
        } 
        printf("%d\n",f[n][1][K]);
    }
    else{
        for(int i=1;i<=n;i++){
            for(int j=1;j<=n;j++){
                for(int k=1;k<=K;k++){
                    f[i][j][k]=max(f[i-1][j][k],f[i][j-1][k]);
                    for(int ed=i-1;ed>=k-1;ed--)f[i][j][k]=max(f[i][j][k],(sum[i][1]-sum[ed][1])+f[ed][j][k-1]);
                    for(int ed=j-1;ed>=k-1;ed--)f[i][j][k]=max(f[i][j][k],(sum[j][2]-sum[ed][2])+f[i][ed][k-1]);
                    if(i==j){
                        for(int ed=i-1;ed>=k-1;ed--){
                            f[i][j][k]=max(f[i][j][k],(sum[i][1]-sum[ed][1])+(sum[j][2]-sum[ed][2])+f[ed][ed][k-1]);
                        }
                    }
                }
            }
        }
        printf("%d\n",f[n][n][K]);
    }
    return 0;
}
Problem1084

#include<cmath>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<iostream>
#include<algorithm>
using namespace std;
int n,m,K,a[110][20],f[110][110][20],sum[110][20];
int main(){
    scanf("%d%d%d",&n,&m,&K);
    memset(sum[0],0,sizeof(sum[0])); 
    for(int i=1;i<=n;i++){
        for(int j=1;j<=m;j++){
            scanf("%d",&a[i][j]);
            sum[i][j]=sum[i-1][j]+a[i][j];
        }
    }
    memset(f,0,sizeof(f));
    if(m==1){
        f[1][1][1]=a[1][1];
        for(int i=2;i<=n;i++){
            for(int k=1;k<=K;k++){
                f[i][1][k]=f[i-1][1][k];
                for(int j=i-1;j>=k-1;j--){
                    f[i][1][k]=max(f[i][1][k],(sum[i][1]-sum[j][1])+f[j][1][k-1]);
                }
            }
        } 
        printf("%d\n",f[n][1][K]);
    }
    else{
        for(int i=1;i<=n;i++){
            for(int j=1;j<=n;j++){
                for(int k=1;k<=K;k++){
                    f[i][j][k]=max(f[i-1][j][k],f[i][j-1][k]);
                    for(int ed=i-1;ed>=k-1;ed--)f[i][j][k]=max(f[i][j][k],(sum[i][1]-sum[ed][1])+f[ed][j][k-1]);
                    for(int ed=j-1;ed>=k-1;ed--)f[i][j][k]=max(f[i][j][k],(sum[j][2]-sum[ed][2])+f[i][ed][k-1]);
                    if(i==j){
                        for(int ed=i-1;ed>=k-1;ed--){
                            f[i][j][k]=max(f[i][j][k],(sum[i][1]-sum[ed][1])+(sum[j][2]-sum[ed][2])+f[ed][ed][k-1]);
                        }
                    }
                }
            }
        }
        printf("%d\n",f[n][n][K]);
    }
    return 0;
}
Problem1085

#include<cmath>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<iostream>
using namespace std;
int a[6][6]={
    {0,0,0,0,0,0},
    {0,1,1,1,1,1},
    {0,0,1,1,1,1},
    {0,0,0,2,1,1},
    {0,0,0,0,0,1},
    {0,0,0,0,0,0}
};
int dx[9]={0,2,2,1,-1,-2,-2,-1,1};
int dy[9]={0,-1,1,2,2,1,-1,-2,-2};
char s[110];
int ed[6][6],xx,yy,n,ans;
bool pd(){
    for(int i=1;i<=5;i++){
        for(int j=1;j<=5;j++){
            if(a[i][j]!=ed[i][j])return false;
        }
    }
    return true;
}
bool star(int k){
    int s=0;
    for(int i=1;i<=5;i++){
        for(int j=1;j<=5;j++){
            if(a[i][j]!=ed[i][j]){
                s++;if(s+k>ans)return false;
            }
        }
    }
    return true;
}
void dfs(int x,int y,int k){
    if(k>ans)return ;
    if(pd()==true){
        ans=min(ans,k);
    }
    else{
        for(int i=1;i<=8;i++){
            int nx=x+dx[i],ny=y+dy[i];
            if(nx>=1&&nx<=5&&ny>=1&&ny<=5){
                swap(a[x][y],a[nx][ny]);
                if(star(k)==true)dfs(nx,ny,k+1);
                swap(a[x][y],a[nx][ny]);
            }
        }
    }
}
int main(){
    scanf("%d",&n);
    while(n--){
        for(int i=1;i<=5;i++){
            scanf("%s",s+1);
            for(int j=1;j<=5;j++){
                if(s[j]=='1')ed[i][j]=1;
                else if(s[j]=='*'){
                    xx=i;yy=j; 
                    ed[i][j]=2;
                }
                else ed[i][j]=0;
            }
        }
        ans=16;
        dfs(3,3,0);
        if(ans!=16)printf("%d\n",ans);
        else printf("-1\n");
    }
}
Problem1086

#include<cmath>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<iostream>
#include<algorithm>
using namespace std;
struct node{
    int x,y,next;
}a[21000];int len,first[11000];
void ins(int x,int y){
    len++;   
    a[len].x=x;a[len].y=y;
    a[len].next=first[x];first[x]=len;
}
int sta[11000],top;
int belong[11000],tot;
int rt[11000],n,L;
void dfs(int fa,int x){
    int now=top;
    for(int k=first[x];k>0;k=a[k].next){
        int y=a[k].y;
        if(y!=fa){
            dfs(x,y);
            if(top-now>=L){
                rt[++tot]=x;
                while(top!=now){
                    belong[sta[top--]]=tot;
                }
            }
        }
    }
    sta[++top]=x;
}
int main(){
    scanf("%d%d",&n,&L);
    if(n<L){printf("0\n");return 0;}
    for(int i=1;i<n;i++){
        int x,y;scanf("%d%d",&x,&y);
        ins(x,y);ins(y,x);
    }
    dfs(0,1);
    while(top>0)belong[sta[top--]]=tot;
    printf("%d\n",tot);
    for(int i=1;i<=n;i++)printf("%d ",belong[i]);printf("\n");
    for(int i=1;i<=tot;i++)printf("%d ",rt[i]);printf("\n");
    return 0;
}
Problem1087

#include<cmath>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<sstream>
#include<iostream>
#include<algorithm>
using namespace std;
typedef long long LL;
struct node{
    LL i,c;
}v[(1<<10)+10];LL vn;
LL f[10][110][(1<<10)+10],d[110];
int main(){
    d[0]=1;for(int i=1;i<=20;i++)d[i]=d[i-1]*2;
    int n,k;
    scanf("%d%d",&n,&k);
    memset(f,0,sizeof(f));
    int mmax=(1<<n)-1;
    for(int i=0;i<=mmax;i++){
        if((i&(i<<1))==0){
            v[++vn].i=i;v[vn].c=0;
            int t=i,p=0;
            while(t!=0){
                if((t&d[p])==d[p]){
                    v[vn].c++;t-=d[p];
                }
                p++;
            }
            f[1][v[vn].c][i]=1;
        } 
    }
    for(int x=2;x<=n;x++){
        for(int p=1;p<=vn;p++){
            for(int q=1;q<=vn;q++){
                if((v[p].i&v[q].i)==0){
                    if(((v[q].i>>1)&v[p].i)==0&&((v[q].i<<1)&v[p].i)==0&&v[p].c+v[q].c<=k){
                        for(int i=v[q].c;i<=k-v[p].c;i++){
                            f[x][v[p].c+i][v[p].i]+=f[x-1][i][v[q].i];
                        }
                    }
                }
            }
        }
    }
    LL ans=0;
    for(int x=1;x<=vn;x++)ans+=f[n][k][v[x].i];
    printf("%lld\n",ans);
    return 0;
}
Problem1088

#include<cmath>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<iostream>
#include<algorithm>
using namespace std;
int n,x[110000],f[110000],ans=0;
bool bk;
int pd(){
    for(int i=2;i<n;i++){
        int tmp=x[i]-f[i]-f[i-1];
        if(tmp<0||tmp>1)return 0;
        else f[i+1]=tmp;
    }
    if(f[n]+f[n-1]!=x[n])return 0;
    return 1;
}
int main()
{
    scanf("%d",&n);
    for(int i=1;i<=n;i++)scanf("%d",&x[i]);
    memset(f,0,sizeof(f));
    if(x[1]>2){printf("0\n");return 0;}
    if(x[n]>2){printf("0\n");return 0;}
    if(x[1]==0){
        memset(f,0,sizeof(f));ans+=pd();
    }
    else if(x[1]==1){
        memset(f,0,sizeof(f));
        f[1]=1;ans+=pd();
        memset(f,0,sizeof(f));
        f[2]=1;ans+=pd();
    }
    else if(x[1]==2){
        f[1]=1;f[2]=1;
        ans+=pd();
    }
    printf("%d\n",ans);
    return 0;
}
Problem1096

#include<cmath>
#include<cstdio>
#include<cstring>   
#include<cstdlib>
#include<iostream>
#include<algorithm>
using namespace std;
long long f[1100000],x[1100000],y[1100000],z[1100000],s[1100000],b[1100000],n,l,r,q[1100000];
inline double slop(int k,int j){
    return (f[j]-f[k]+b[j]-b[k])/(1.0*s[j]-s[k]);
}
int main(){
    while(scanf("%lld",&n)!=EOF){
        s[0]=0;b[0]=0;
        for(int i=1;i<=n;i++){
            scanf("%lld%lld%lld",&x[i],&y[i],&z[i]);
            s[i]=s[i-1]+y[i];
            b[i]=b[i-1]+x[i]*y[i];
        }
        q[1]=0;l=r=1;
        for(int i=1;i<=n;i++){
            while(l<r&&slop(q[l],q[l+1])<x[i])l++;
            int tmp=q[l];
            f[i]=f[tmp]+(s[i]-s[tmp])*x[i]-(b[i]-b[tmp])+z[i];
            while(l<r&&slop(q[r],i)<slop(q[r-1],q[r]))r--;
            q[++r]=i;
        }
        printf("%lld",f[n]);
    }
    return 0;
}   
Problem1192

#include<cmath>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<iostream>
#include<algorithm>
using namespace std;
int n,ans=0;
int main(){
    scanf("%d",&n);
    while(n!=0){
        ans++;n/=2;
    }
    printf("%d\n",ans);
    return 0;
}
Problem1192

#include<cstdio>
int n,ans=0;
int main(){
    scanf("%d",&n);
    while(n!=0){
        ans++;n/=2;
    }
    printf("%d\n",ans);
    return 0;
}
Problem1407

#include<cmath>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<iostream>
#include<algorithm>
using namespace std;
typedef long long LL;
LL n,maxx,c[1100],p[1100],k[1100];
LL gcd(LL a,LL b){return a==0?b:gcd(b%a,a);}
LL exgcd(LL a,LL b,LL &x,LL &y){
    if(a==0){
        x=0;y=1;
        return b;
    }
    else{ 
        LL tx,ty;
        LL d=exgcd(b%a,a,tx,ty);
        x=ty-(b/a)*tx;
        y=tx;
        return d; 
    } 
}
bool pd(int m)
{
    LL a,b,cc,t,x,y;
    for(int i=1;i<=n;i++)
        for(int j=i+1;j<=n;j++)
        {
            a=p[i]-p[j],b=m,cc=c[j]-c[i];
            t=gcd(a,b);
            if(cc%t==0)
            {
                a/=t;b/=t;cc/=t;
                exgcd(a,b,x,y);
                b=abs(b);
                x=((cc*x)%b+b)%b;
                if(!x)x+=b;
                if(x<=min(k[i],k[j]))return 0;
            }
        }
    return 1;
}
int main(){
    scanf("%lld",&n);
    for(int i=1;i<=n;i++){
        scanf("%lld%lld%lld",&c[i],&p[i],&k[i]);maxx=max(c[i],maxx);
    }
    for(int i=maxx;;i++){
        if(pd(i)==true){
            printf("%d\n",i);
            return 0;
        }
    }
}
Problem1407

#include<cmath>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<iostream>
#include<algorithm>
using namespace std;
typedef long long LL;
LL n,maxx,c[1100],p[1100],k[1100];
LL gcd(LL a,LL b){return a==0?b:gcd(b%a,a);}
LL exgcd(LL a,LL b,LL &x,LL &y){
    if(a==0){
        x=0;y=1;
        return b;
    }
    else{ 
        LL tx,ty;
        LL d=exgcd(b%a,a,tx,ty);
        x=ty-(b/a)*tx;
        y=tx;
        return d; 
    } 
}
bool pd(int m){
    for(int i=1;i<=n;i++){
        for(int j=i+1;j<=n;j++){
            LL aa,bb,cc,t,x,y;
            aa=p[i]-p[j];bb=m;cc=c[j]-c[i];
            t=gcd(aa,bb);
            if(cc%t==0){
                aa/=t;bb/=t;cc/=t;
                LL d=exgcd(aa,bb,x,y);
                bb=abs(bb);
                x=((cc*x)%bb+bb)%bb;
                if(x<=0)x+=bb;
                if(x<=min(k[i],k[j]))return false;
            }
        }
    }
    return true; 
}
int main(){
    scanf("%lld",&n);
    for(int i=1;i<=n;i++){
        scanf("%lld%lld%lld",&c[i],&p[i],&k[i]);maxx=max(c[i],maxx);
    }
    for(int i=maxx;;i++){
        if(pd(i)==true){
            printf("%d\n",i);
            return 0;
        }
    }
}
Problem1597

#include<cstdio>
#include<cstring>
#include<cstdlib>
using namespace std;
typedef long long LL;
struct node{ LL x,y;}a[51000],b[51000];
int cmp(const void *xx,const void *yy)
{
    node n1=*(node *)xx;
    node n2=*(node *)yy;
    if( n1.x>n2.x) return 1;
    if( n1.x<n2.x) return -1;
    if( n1.y>n2.y) return 1;
    if( n1.y<n2.y) return -1;
    return 0;
}
long long  f[51000];
int q[51000],l,r;

double slop(int j1,int j2)
{
    return   double( f[j2]-f[j1] )/( b[j1+1].y-b[j2+1].y );
}
int main()
{
    //freopen("acquire.in","r",stdin);freopen("acquire.out","w",stdout);
    int n;scanf("%d",&n);
    for(int i=1;i<=n;i++)scanf("%lld%lld",&a[i].x,&a[i].y);
    qsort(a+1,n,sizeof(node),cmp);

    int p=1;b[1]=a[1];
    for(int i=2;i<=n;i++)
    {
        while(p>0 && b[p].y<=a[i].y)p--;
        b[++p]=a[i];
    }

    l=r=1;q[1]=0;
    for(int i=1;i<=p;i++)
    {
        while(l<r && slop(q[l],q[l+1])<b[i].x)l++;

        f[i]= f[q[l]]+ b[q[l]+1].y*b[i].x ;

        while(l<r&& slop(q[r-1],q[r])>slop(q[r],i) )r--;

        q[++r]=i;
    }
    printf("%lld\n",f[p]);
    return 0;
}
Problem1597

#include<cmath>
#include<cstdio>
#include<cstring>   
#include<cstdlib>
#include<iostream>
#include<algorithm>
using namespace std;
struct node{
    long long x,y;
}a[51000],b[51000];
int cmp(const void *xx,const void *yy){
    node n1=*(node *)xx;
    node n2=*(node *)yy;
    if(n1.x>n2.x)return 1;
    else if(n1.x<n2.x)return -1;
    else if(n1.y>n2.y)return 1;
    else if(n1.y<n2.y)return -1;
    else return 0;
}
long long n,len,l,r,tmp,f[51000],q[51000];
double slop(int j,int k){
    return double(f[k]-f[j])/(b[j+1].y-b[k+1].y);
}
int main(){
    //freopen("acquire.in","r",stdin);
    //freopen("acquire.out","w",stdout);
    scanf("%lld",&n);;
    for(int i=1;i<=n;i++)scanf("%lld%lld",&a[i].x,&a[i].y);
    qsort(a+1,n,sizeof(node),cmp);
    len=1;b[1]=a[1];
    for(int i=2;i<=n;i++){
        while(len>0&&b[len].y<=a[i].y)len--;
        b[++len]=a[i];
    }
    l=r=1;q[1]=0;
    for(int i=1;i<=len;i++){
        while(l<r&&slop(q[l],q[l+1])<=b[i].x)l++;
        f[i]=f[q[l]]+b[q[l]+1].y*b[i].x;
        while(l<r&&slop(q[r-1],q[r])>slop(q[r],i))r--;
        q[++r]=i; 
    }
    printf("%lld",f[len]);
    return 0;
}  
Problem1854

#include<set>
#include<cmath>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<iostream>
#include<algorithm>
using namespace std;
int n,fa[1100000];
bool v[1100000];
int findfa(int x){
    if(x==fa[x])return x;
    else return fa[x]=findfa(fa[x]);
}
void un(int x,int y){
    if(x<y)swap(x,y);
    v[y]=true;
    fa[y]=x;
}
int main(){
    scanf("%d",&n);
    for(int i=1;i<=n+1;i++)fa[i]=i;
    for(int i=1;i<=n;i++){
        int x,y;
        scanf("%d%d",&x,&y);
        int fx=findfa(x),fy=findfa(y);
        if(fx==fy)v[fx]=true;
        else un(fx,fy);
    }
    for(int i=1;i<=n+1;i++){
        if(v[i]==false){
            printf("%d\n",i-1);
            return 0;
        }
    }
    return 0;
}
Problem2049

#include<cmath>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<iostream>
#include<algorithm>
using namespace std;
int fa[11000],n,m;char s[110];
int find_root(int u){
    while(u!=fa[u])u=fa[u];
    return u;
}   
bool query(int u,int v){
    return find_root(u)==find_root(v);  
}
void mark_root(int p){
    int x,y,z;
    x=p;y=fa[x];
    while(x!=y){
        z=fa[y];fa[y]=x;
        x=y;y=z;    
    }
    fa[p]=p;
}
void destroy(int u,int v){
    mark_root(u);
    fa[v]=v;
}
void connect(int u,int v){
    mark_root(u);
    mark_root(v);
    fa[v]=u;
}
int main(){
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++)fa[i]=i;
    while(m--){
        int x,y;
        scanf("%s%d%d",s+1,&x,&y);
        if(s[1]=='Q'){
            if(query(x,y)==true)printf("Yes\n");
            else printf("No\n");
        }
        else if(s[1]=='C')connect(x,y);
        else destroy(x,y);
    }
}
Problem2049

#include<cmath>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<iostream>
#include<algorithm>
using namespace std;
int f[11000],n,m;char s[110];
int find_root(int u){
    while(u!=f[u])u=f[u];
    return u;
}   
bool query(int u,int v){
    return find_root(u)==find_root(v);  
}
void mark_root(int p){
    int x,y,z;
    x=p;y=f[x];
    while(x!=y){
        z=f[y];f[y]=x;
        x=y;y=z;    
    }
    f[p]=p;
}
void destroy(int u,int v){
    mark_root(u); 
    f[v]=v;
}
void connect(int u,int v){
    mark_root(u);
    mark_root(v);
    f[v]=u;
}
int main(){
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++)f[i]=i;
    while(m--){
        int x,y;
        scanf("%s%d%d",s+1,&x,&y);
        if(s[1]=='Q'){
            if(query(x,y)==true)printf("Yes\n");
            else printf("No\n");
        }
        else if(s[1]=='C')connect(x,y);
        else destroy(x,y);
    }
}
Problem2763

#include<cmath>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<iostream>
#include<algorithm>
using namespace std;
struct node{
    int x,y,c,next;
}a[210000];int len,first[110000];
void ins(int x,int y,int c){
    len++;
    a[len].x=x;a[len].y=y;a[len].c=c;
    a[len].next=first[x];first[x]=len;
}
int d[110000][11],list[110000][11],head,tail,ans,n,m,p,st,ed;;
bool v[110000][11];
int main(){
    scanf("%d%d%d",&n,&m,&p);
    scanf("%d%d",&st,&ed);
    for(int i=1;i<=m;i++){
        int x,y,c;
        scanf("%d%d%d",&x,&y,&c);
        ins(x,y,c);ins(y,x,c);
    }
    memset(d,31,sizeof(d));d[st][0]=0;
    memset(v,false,sizeof(v));v[st][0]=true;
    head=1;tail=2;list[1][0]=st;list[1][1]=0;
    while(head!=tail){
        int x=list[head][0];int c=list[head][1];
        for(int k=first[x];k>0;k=a[k].next){
            int y=a[k].y;
            if(d[x][c]+a[k].c<d[y][c]){
                d[y][c]=d[x][c]+a[k].c;
                if(v[y][c]==false){
                    v[y][c]=true;
                    list[tail][0]=y;list[tail++][1]=c;
                    if(tail==100001) tail=1;
                }
            }
            if(d[x][c]<d[y][c+1]&&c<p){
                d[y][c+1]=d[x][c];
                if(v[y][c+1]==false){
                    v[y][c+1]=true;
                    list[tail][0]=y;list[tail++][1]=c+1;
                    if(tail==100001) tail=1;
                }
            }
        }
        head++; 
        if(head==100001) head=1;
        v[x][c]=false;
    }
    ans=999999999;
    for(int i=0;i<=p;i++)ans=min(ans,d[ed][i]);
    printf("%d\n",ans);
    return 0;
}
Problem3573

#include<cmath>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<iostream>
#include<algorithm>
using namespace std;
int n;
double a[510000],s[510000],f[510000];
int d[510000];
bool v[510000];
struct node{
    int x,y,next;
}e[1100000];int len,first[510000];
void ins(int x,int y) {
    len++;
    e[len].x=x;e[len].y=y;
    e[len].next=first[x];first[x]=len;
}
void dfs(int x){
    for(int k=first[x];k>0;k=e[k].next){
        int y=e[k].y;
        if(v[y]==false){
            v[y]=true;
            s[y]=s[x]+log(d[x]);
            dfs(y);
        }
    }
}
int main(){
    scanf("%d",&n);
    for(int i=1;i<=n;i++)scanf("%d",&a[i]);
    len=0;memset(first,0,sizeof(first));
    for(int i=1;i<n;i++){
        int x,y;
        scanf("%d%d",&x,&y);
        ins(x,y);ins(y,x);
        d[x]++;d[y]++;
    }
    for(int i=2;i<=n;i++)d[i]--;
    s[1]=0.0;
    memset(v,false,sizeof(v));v[1]=true;
    dfs(1); 
    for(int i=1;i<=n;i++)f[i]=s[i]+log(a[i]);
    sort(f+1,f+n+1);
    int tmp=1,ans=0;
    for(int i=2;i<=n;i++){
        if(f[i]-f[i-1]<0.000001)tmp++;
        else{
            ans=max(ans,tmp);tmp=1;
        }
    }
    ans=max(ans,tmp);
    printf("%d\n",n-ans);
    return 0;
}
Problem3573

#include<cmath>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<iostream>
#include<algorithm>
using namespace std;
int n;
double a[510000],s[510000],f[510000];
int d[510000];
bool v[510000];
struct node
{
    int x,y,next;
}e[1100000];int len,first[510000];
void ins(int x,int y)
{
    len++;
    e[len].x=x;e[len].y=y;
    e[len].next=first[x];first[x]=len;
}
void dfs(int x)
{
    for(int k=first[x];k>0;k=e[k].next)
    {
        int y=e[k].y;
        if(v[y]==false){
            v[y]=true;
            s[y]=s[x]+log(d[x]);//把大数据简化成小数据 
            dfs(y);
        }
    }
}
int main(){
    scanf("%d",&n);
    for(int i=1;i<=n;i++)scanf("%lf",&a[i]);
    len=0;memset(first,0,sizeof(first));
    for(int i=1;i<n;i++)
    {
        int x,y;
        scanf("%d%d",&x,&y);
        ins(x,y);ins(y,x);
        d[x]++;d[y]++;
    }
    for(int i=2;i<=n;i++)d[i]--;
    s[1]=0.0;
    memset(v,false,sizeof(v));v[1]=true;
    dfs(1); 
    for(int i=1;i<=n;i++)f[i]=s[i]+log(a[i]);//减少了很多很多的数据 
//  for(int i=1;i<=n;i++)printf("s[%d] %lf\n",i,s[i]);
//  for(int i=1;i<=n;i++)printf("f[%d] %lf\n",i,f[i]);
//  for(int i=1;i<=n;i++)printf("a[%d] %lf\n",i,a[i]);

    sort(f+1,f+n+1);
    int tmp=1,ans=0;
    for(int i=2;i<=n;i++)
    {
        if(f[i]-f[i-1]<0.000001)tmp++;
        else
        {
            ans=max(ans,tmp);tmp=1;
        }
    }
    ans=max(ans,tmp);
    printf("%d\n",n-ans);
    return 0;
}
Problem3573

#include<cmath>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<iostream>
#include<algorithm>
using namespace std;
int n;
double a[510000],s[510000],f[510000];
int d[510000];
bool v[510000];
struct node{
    int x,y,next;
}e[1100000];int len,first[510000];
void ins(int x,int y) {
    len++;
    e[len].x=x;e[len].y=y;
    e[len].next=first[x];first[x]=len;
}
void dfs(int x){
    for(int k=first[x];k>0;k=e[k].next){
        int y=e[k].y;
        if(v[y]==false){
            v[y]=true;
            s[y]=s[x]+log(d[x]);//把大数据简化成小数据 
            dfs(y);
        }
    }
}
int main(){
    scanf("%d",&n);
    for(int i=1;i<=n;i++)scanf("%lf",&a[i]);
    len=0;memset(first,0,sizeof(first));
    for(int i=1;i<n;i++){
        int x,y;
        scanf("%d%d",&x,&y);
        ins(x,y);ins(y,x);
        d[x]++;d[y]++;
    }
    for(int i=2;i<=n;i++)d[i]--;//为什么要减一 ,Son!
    s[1]=0.0;   
    memset(v,false,sizeof(v));v[1]=true; 
    dfs(1); 
    for(int i=1;i<=n;i++)f[i]=s[i]+log(a[i]);//减少了很多很多的数据 
    sort(f+1,f+n+1);
    int tmp=1,ans=0;  
    for(int i=2;i<=n;i++){
        if(f[i]-f[i-1]<0.000001)tmp++;
        else{
            ans=max(ans,tmp);tmp=1;
        }
    } 
    ans=max(ans,tmp);
    printf("%d\n",n-ans);
    return 0; 
}
Problem4027

#include<cmath>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<iostream>
#include<algorithm>
using namespace std;
int d[2100000],n,m;
struct node{
    int x,y,next;
}a[4100000];int len,last[2100000];
int ss[2100000],son[2100000];
void ins(int x,int y) {
    len++;a[len].x=x;a[len].y=y;
    a[len].next=last[x];last[x]=len;
}
int aa[2100000];
int f[2100000];
int cmp(const void *xx,const void *yy){
    int n1=*(int *)xx;
    int n2=*(int *)yy;
    return d[n1]-d[n2];
}
int ans=0;
void dfs(int x){
    int len=0;
    for(int k=last[x];k;k=a[k].next){
        int y=a[k].y;
        dfs(y);
    }
    for(int k=last[x];k;k=a[k].next){
        int y=a[k].y;
        ss[++len]=y;
    }
    d[x]+=son[x];
    qsort(ss+1,len,sizeof(int),cmp);
    for(int i=1;i<=len;i++){
        int y=ss[i];
        if(d[x]+d[y]-1<=m){
            ans++;d[x]+=d[y]-1;
        }
        else break;
    }
}
int main(){
    scanf("%d%d",&n,&m);
    len=0;memset(last,0,sizeof(last));
    for(int i=0;i<n;i++){
        scanf("%d",&aa[i]);
        d[i]=aa[i];
    }
    for(int i=0;i<n;i++){
        scanf("%d",&son[i]);
        for(int j=1;j<=son[i];j++){
            int y;scanf("%d",&y);
            ins(i,y);
        }
    }
    ans=0;dfs(0);
    printf("%d\n",ans);
    return 0;
}
Problem4196

#include<set>
#include<map>
#include<cmath>
#include<cstdio>
#include<vector>
#include<cstring>
#include<cstdlib>
#include<iostream>
#include<algorithm>
using namespace std;
struct node{
    int x,y,d,next;
}a[210000];int len,first[110000],n,m,fa[110000],dep[110000],son[110000],tot[110000],z,ys[110000],top[110000],xx,yy,tmp,tt,ans;
bool v[110000];
void ins(int x,int y){
    len++;
    a[len].x=x;a[len].y=y;
    a[len].next=first[x];first[x]=len;
}
struct tree{
    int lc,rc,l,r,c,s;
}tr[210000];int trlen;
void bt(int l,int r){
    trlen++;
    int now=trlen;
    tr[now].l=l;tr[now].r=r;tr[now].c=0;tr[now].s=0;
    tr[now].lc=tr[now].rc=-1;
    if(l<r){
        int mid=(l+r)/2;
        tr[now].lc=trlen+1;bt(l,mid);
        tr[now].rc=trlen+1;bt(mid+1,r);
    }
}
void prenode(int x){
    tot[x]=1;son[x]=0;
    for(int k=first[x];k>0;k=a[k].next){
        int y=a[k].y;
        if(y!=fa[x]){
            fa[y]=x;
//            v[y]=false;
            dep[y]=dep[x]+1;
            prenode(y);
            if(tot[son[x]]<tot[y])son[x]=y;
            tot[x]+=tot[y];
        } 
    }
}
void preedge(int x,int tp){
    ys[x]=++z;top[x]=tp; 
    if(son[x]!=0){
//        v[son[x]]=false;
        preedge(son[x],tp);
    }
    for(int k=first[x];k>0;k=a[k].next){
        int y=a[k].y;
        if(y!=fa[x]&&son[x]!=y){
//            v[y]=false;
            preedge(y,y);  
        }
    }
}
void change(int now,int l,int r,int c){
    if(tr[now].l==l&&tr[now].r==r){
        if(c==0)ans+=tr[now].s;
        else ans+=((tr[now].r-tr[now].l+1)-tr[now].s);
        tr[now].c=c;
        tr[now].s=c*(tr[now].r-tr[now].l+1);
        return ;
    }
    int lc=tr[now].lc,rc=tr[now].rc,mid=(tr[now].l+tr[now].r)/2;
    if(tr[now].c>=0){
        tr[lc].c=tr[rc].c=tr[now].c;
        tr[lc].s=tr[lc].c*(tr[lc].r-tr[lc].l+1);
        tr[rc].s=tr[rc].c*(tr[rc].r-tr[rc].l+1);
    }
    if(r<=mid)change(lc,l,r,c);
    else if(mid+1<=l)change(rc,l,r,c);
    else{change(lc,l,mid,c);change(rc,mid+1,r,c);}
    if(tr[lc].c==tr[rc].c)tr[now].c=tr[lc].c;else tr[now].c=-1;
    tr[now].s=tr[lc].s+tr[rc].s;
}
int main(){ 
    //freopen("manager.in","r",stdin);
    //freopen("manager.out","w",stdout);
    scanf("%d",&n);
    len=0;memset(first,0,sizeof(first));
    for(int i=2;i<=n;i++){scanf("%d",&xx);xx++;ins(xx,i);}
    dep[1]=0;fa[1]=0;prenode(1);
    z=0;preedge(1,1);
    trlen=0;bt(1,z);tr[1].c=0;
    scanf("%d",&tmp);
    while(tmp--){
        char ss[110];
        scanf("%s%d",ss+1,&xx);xx++;
        if(ss[1]=='i'){
            ans=0;
            int tx=top[xx];
            while(xx!=0){
                change(1,ys[tx],ys[xx],1); 
                xx=fa[tx];tx=top[xx];
            }
            printf("%d\n",ans);
        }
        else{
            ans=0;change(1,ys[xx],ys[xx]+tot[xx]-1,0);
            printf("%d\n",ans);
        }
    }
    return 0;
}