Forethought Future Cup

A.最长不会超过a的个数的两倍-1。

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#define rep(i,l,r) for (int i=(l); i<=(r); i++)
typedef long long ll;
using namespace std;

const int N=100;
int n,d;
char s[N];

int main(){
    scanf("%s",s+1); n=strlen(s+1);
    rep(i,1,n) if (s[i]=='a') d++;
    printf("%d
",min(d*2-1,n));
    return 0;
}

B.删除所有a后一定是两个完全相同的串接起来。

#include<string>
#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#define rep(i,l,r) for (int i=(l); i<=(r); i++)
typedef long long ll;
using namespace std;

string s,t;

int main(){
    cin>>s; int l=s.length();
    rep(i,0,l-1) if (s[i]!='a') t+=s[i];
    if (t.length()&1){ puts(":("); return 0; }
    int p=t.length()/2;
    string t1=t.substr(0,p),t2=t.substr(p,p);
    if (t1==t2 && t1==s.substr(s.length()-p,p)) cout<<s.substr(0,s.length()-p)<<endl;
        else  puts(":(");
    return 0;
}

C.一种方法是直接二进制分组，能处理图的情况。

另一种是回顾一种树上找直径的方法，先任选一个点u找到离它最远的一个点v，再从v开始找到离它最远的点w，v到w就是直径。

这道题先任选u，然后通过二分点集找到最远点v，再一次查询即可得到直径。

#include<string>
#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#define rep(i,l,r) for (int i=(l); i<=(r); i++)
typedef long long ll;
using namespace std;

string s,t;

int main(){
    cin>>s; int l=s.length();
    rep(i,0,l-1) if (s[i]!='a') t+=s[i];
    if (t.length()&1){ puts(":("); return 0; }
    int p=t.length()/2;
    string t1=t.substr(0,p),t2=t.substr(p,p);
    if (t1==t2 && t1==s.substr(s.length()-p,p)) cout<<s.substr(0,s.length()-p)<<endl;
        else  puts(":(");
    return 0;
}

F.有多种做法，我的f[i][0/1/2]表示以i为根的子树中，所有叶子(包括根)都已经被确定分到某集合中/存在叶子未被划分集合(它们将和i以上的点配对)/所有叶子都已划分但根不属于任何一个集合，的方案数。转移显然，主要关注初始值的设定，叶子和非叶节点是不一样的。

#include<cstdio>
#include<algorithm>
#define rep(i,l,r) for (int i=(l); i<=(r); i++)
#define For(i,x) for (int i=h[x],k; i; i=nxt[i])
using namespace std;

const int N=200010,mod=998244353;
int n,cnt,fa[N],f[N][3],h[N],to[N],nxt[N];

void add(int u,int v){ to[++cnt]=v; nxt[cnt]=h[u]; h[u]=cnt; }

void dfs(int x){
    if (!h[x]){ f[x][1]=f[x][2]=1; return; }
    f[x][2]=1;
    For(i,x){
        dfs(k=to[i]);
        f[x][0]=(1ll*f[x][0]*(f[k][0]+f[k][2])+1ll*f[x][1]*f[k][1])%mod;
        f[x][1]=(1ll*(f[x][1]+f[x][2])*f[k][1]+1ll*f[x][1]*(f[k][0]+f[k][2]))%mod;
        f[x][2]=1ll*f[x][2]*(f[k][0]+f[k][2])%mod;
    }
}

int main(){
    scanf("%d",&n);
    rep(i,2,n) scanf("%d",&fa[i]),add(fa[i],i);
    dfs(1); printf("%d
",(f[1][0]+f[1][2])%mod);
    return 0;
}

G.每个建筑拆成h+1个点分别代表它的高度为[0,h]，第i-1个点向第i个点连流量为h^2-i^2的边，第h个点向T连流量无穷的边。对于每个询问，将[l,r]中的代表高度h的点全部连向一个新点，流量无穷，再从新点向T连流量为c的边。n*h*h-最小割就是最终答案。

#include<cstdio>
#include<algorithm>
#define rep(i,l,r) for (int i=(l); i<=(r); i++)
#define For(i,x) for (int i=h[x],k; i; i=nxt[i])
using namespace std;

const int N=10010,inf=1e9;
int n,H,m,S,T,l,r,x,c,ans,q[N],cur[N],d[N],cnt=1,h[N],to[N],nxt[N],fl[N];

int F(int i,int j){ return (i-1)*(H+1)+j+1; }

void add(int u,int v,int w){
    to[++cnt]=v; fl[cnt]=w; nxt[cnt]=h[u]; h[u]=cnt;
    to[++cnt]=u; fl[cnt]=0; nxt[cnt]=h[v]; h[v]=cnt;
}

bool bfs(){
    rep(i,1,T+m) d[i]=0; d[S]=1; q[1]=S;
    for (int st=0,ed=1; st!=ed; ){
        int x=q[++st];
        For(i,x) if (fl[i] && !d[k=to[i]])
            d[k]=d[x]+1,q[++ed]=k;
    }
    return d[T];
}

int dfs(int x,int lim){
    if (x==T) return lim;
    int c=0;
    for (int &i=cur[x],k; i; i=nxt[i])
        if (fl[i] && d[k=to[i]]==d[x]+1){
            int t=dfs(k,min(lim-c,fl[i]));
            c+=t; fl[i]-=t; fl[i^1]+=t;
            if (c==lim) return c;
        }
    if (!c) d[x]=-1;
    return c;
}

int main(){
    scanf("%d%d%d",&n,&H,&m); S=F(n,H)+1; T=S+1;
    rep(i,1,n){
        add(S,F(i,0),H*H);
        rep(j,1,H) add(F(i,j-1),F(i,j),H*H-j*j);
        add(F(i,H),T,inf);
    }
    rep(i,1,m){
        scanf("%d%d%d%d",&l,&r,&x,&c);
        rep(j,l,r) add(F(j,x),T+i,inf);
        add(T+i,T,c);
    }
    while (bfs()){
        rep(i,1,T+m) cur[i]=h[i];
        ans+=dfs(S,inf);
    }
    printf("%d
",n*H*H-ans);
    return 0;
}

H.显然就是求五个点的凸包个数。一个方法是枚举上顶点，将所有点按相对于它的极角排序，再枚举第3,4个点，第2,5个点就是前缀后缀中满足某条件的点的个数，树状数组在线统计一下即可。$O(n^3log n)$

另一个方法是f[i][j][k(0..5)]表示第一个点为i,当前确定了k条边，最后一个点是j，的方案数。将所有边按斜率排序，然后跑类似Bellman-Ford即可。$O(n^3)$

#include<cstdio>
#include<iostream>
#include<algorithm>
#define rep(i,l,r) for (int i=(l); i<=(r); i++)
typedef long long ll;
using namespace std;

const int N=310;
int n,tot;
ll ans,f[N][N][6];
struct P{ int x,y; }p[N];
struct L{ P x; int a,b; }e[N*N];

P operator -(const P &a,const P &b){ return (P){a.x-b.x,a.y-b.y}; }
P operator +(const P &a,const P &b){ return (P){a.x+b.x,a.y+b.y}; }
ll operator *(const P &a,const P &b){ return 1ll*a.x*b.y-1ll*b.x*a.y; }
bool operator <(const P &a,const P &b){ return a*b<0; }
bool operator <(const L &a,const L &b){
    if (a.x<b.x) return 1;
    if (b.x<a.x) return 0;
    return a.a==b.a ? a.b<b.b : a.a<b.a;
}

int main(){
    scanf("%d",&n);
    rep(i,1,n) scanf("%d%d",&p[i].x,&p[i].y);
    rep(i,1,n) rep(j,1,n) if (i!=j) e[++tot]=(L){p[j]-p[i],i,j};
    sort(e+1,e+tot+1);
    rep(i,1,tot){
        int u=e[i].a,v=e[i].b; f[u][v][1]++;
        rep(i,1,5) rep(j,1,n) f[j][v][i+1]+=f[j][u][i];
    }
    rep(i,1,n) ans+=f[i][i][5];
    cout<<ans<<endl;
    return 0;
}