TJOI2015 day1解题报告

博客园的编辑器真的是太蛋疼了= =，想用tex然后上jpg又贴不了链接，真的很纠结啊= =

T1:[TJOI2015]线性代数

描述:戳上面吧= =

首先这道题我觉得是这套题最漂亮的一道题了（虽然说学校的题库里居然有一道和这个一模一样的= =）

首先我们可以先把那个式子转化为其中b[i]是表示矩阵a中第i行为0或为1，然后就有两种方法转化为网络流啦

方法一：可以用最大权闭合子图的方法来考虑，将c[i]以及a[i][j]的选择与否视为事件的话，可以发现是一个点数为n*n的最大权闭合子图，就可以愉快的用网络流来搞辣

方法二：我们可以看做一个二元关系，因为可以看做i的选取会花费 c[i]，而同时选择i, j则会获得一定的收益，那么我们可以得到一个二元关系（但还是需要经过一定的转化的），然后点数就只有n啦

我只写了方法一，虽说点数很多，但边数少，还是很快的

还有一种水法，貌似直接把所有a相加然后减去b就行辣（数据就是这么水= =）

CODE：

 #include<cstdio>
 #include<iostream>
 #include<cstring>
 #include<algorithm>
 using namespace std;
 #define maxn 300000
 #define maxm 900000
 struct edges{
     int to,next,cap;
 }edge[maxm*];
 int next[maxn],l;
 inline void addedge(int x,int y,int z) {
     l++;
     edge[l*]=(edges){y,next[x],z};next[x]=l*;
     edge[l*+]=(edges){x,next[y],};next[y]=l*+;
 }
 #define inf 0x7fffffff
 int s,t,h[maxn],p[maxn],gap[maxn];
 int sap(int u,int flow) {
     if (u==t) return flow;
     int cnt=;
     for (int i=p[u];i;i=edge[i].next)
         if (edge[i].cap&&h[u]==h[edge[i].to]+) {
             int cur=sap(edge[i].to,min(flow-cnt,edge[i].cap));
             edge[i].cap-=cur;edge[i^].cap+=cur;
             p[u]=i;
             if ((cnt+=cur)==flow) return cnt;
         }
     if (!(--gap[h[u]])) h[s]=t;
     gap[++h[u]]++;
     p[u]=next[u];
     return cnt;
 }
 inline int maxflow(){
     for (int i=;i<=t;i++) p[i]=next[i];
     memset(gap,,sizeof(gap));
     memset(h,,sizeof(h));
     gap[]=t;
     int flow=;
     while (h[s]<t) flow+=sap(s,inf);
     return flow;
 }
 int id[][],cnt,n;
 int main(){
     freopen("algebra.in","r",stdin);
     freopen("algebra.out","w",stdout);
     scanf("%d",&n);
     for (int i=;i<=n;i++)
         for (int j=;j<=n;j++) id[i][j]=++cnt;
     s=++cnt,t=++cnt;
     int sum=;
     for (int i=;i<=n;i++)
         for (int j=;j<=n;j++) {
             int x;
             scanf("%d",&x);
             addedge(s,id[i][j],x);
             sum+=x;
         }
     for (int i=;i<=n;i++) {
         int x;
         scanf("%d",&x);
         addedge(id[][i],t,x);
     }
     for (int i=;i<=n;i++)
         for (int j=;j<=n;j++) {
             addedge(id[i][j],id[][i],inf);
             addedge(id[i][j],id[][j],inf);
         }
     printf("%d\n",sum-maxflow());
     return ;
 }

T2：[TJOI2015]组合数学

这是道结论题= =

某个啥啥定理说：DAG的最小链覆盖=最大独立点集，可见网格图的最大独立点集一定是从右上到左下的一条路径，那么我们就可以直接dp搞了

CODE：

 #include<cstdio>
 #include<iostream>
 #include<algorithm>
 #include<cstring>
 using namespace std;
 #define maxn 1100
 int f[maxn][maxn],a[maxn][maxn],T,n,m;
 int main(){
     freopen("math.in","r",stdin);
     freopen("math.out","w",stdout);
     scanf("%d",&T);
     while (T--) {
         memset(f,,sizeof(f));
         scanf("%d%d",&n,&m);
         for (int i=;i<=n;i++)
             for (int j=;j<=m;j++) scanf("%d",a[i]+j);
             int ans=;
         for (int i=n;i;i--)
             for (int j=;j<=m;j++) {
                 f[i][j]=max(f[i][j-],max(f[i+][j-]+a[i][j],f[i+][j]));
                 ans=max(ans,f[i][j]);
             }
         printf("%d\n",ans);
     }
     return ;
 }

T3：[TJOI2015]弦论

这道题嘛= =，50分算法是深圳市选题，然后100分的话我们可以用SAM来解决这个问题

首先我们先来考虑一下50分的算法，SAM上的每一个节点都表示该图中的一个子串，所以我们可以类似dp求出答案

而对于T=1的时候，可以发现重复的字串其实都在以parents树上该节点为根的子树

所以我们还是可以dp一下求出来

八中上被卡常数了，老调不出来

CODE:

 #include<cstdio>
 #include<iostream>
 #include<algorithm>
 #include<cstring>
 using namespace std;
 #define maxn 1001000
 char s[maxn];
 typedef long long ll;
 struct sam{
     sam *pre,*ch[];
     int val,cnt;ll size;
     bool b;
 }_t[maxn];
 sam *root,*last;
 int t,cnt;
 inline void add(int x) {
     sam *p=last;
     _t[++cnt].val=last->val+;
     sam *np=_t+cnt;
     while (p&&p->ch[x]==) p->ch[x]=np,p=p->pre;
     if (p==) np->pre=root;
     else {
         sam* q=p->ch[x];
         if (p->val+==q->val) np->pre=q;
         else {
             _t[++cnt].val=p->val+;
             sam*nq=_t+cnt;
             memcpy(nq->ch,q->ch,sizeof(q->ch));
             nq->pre=q->pre;
             np->pre=q->pre=nq;
             while (p&&p->ch[x]==q) p->ch[x]=nq,p=p->pre;
         }
     }
     last=np;
 }
 inline void bfs(){
     static sam* q[maxn];
     q[]=root;
     sam* u=q[];
     int l,r;
     for (l=r=;l<=r;u=q[++l]) {
         for (int i=;i<;i++) {
             if (!u->ch[i]||u->ch[i]->b) continue;
                u->ch[i]->b=;
                q[++r]=u->ch[i];
         }
     }
     u=q[r];
     for (int i=r;i;u=q[--i]) {
         if (!t) u->cnt=;
         if (i==) u->cnt=;
         if (u->pre) u->pre->cnt+=u->cnt;
     }
 }
 char ans[maxn];
 int l;
 void dfs(sam *p){
     int i;
     p->b=;
     p->size=p->cnt;
     for(i=;i<;i++)
         if(p->ch[i]){
             if(p->ch[i]->b==) dfs(p->ch[i]);
              p->size+=p->ch[i]->size;
         }
 }
 int k;
 void get(sam *p){
     int i;
     if(k<=p->cnt) return ;
     k-=p->cnt;
     for(i=;i<;i++)
         if(p->ch[i]){
             if(k<=p->ch[i]->size){
                ans[++l]=i+'a';
                get(p->ch[i]);
                return ;
            }
            k-=p->ch[i]->size;
        }
 }
 int main(){
     scanf("%s%d%d",&s,&t,&k);
     root=_t;
     root->val=;last=root;
     int n=strlen(s);
     for (int i=;i<n;i++) {
         add(s[i]-'a');
         last->cnt=;
     }
     bfs();
     dfs(root);
     if (root->size<k) {
         printf("-1\n");
         return ;
     }
     get(root);
     printf("%s\n",ans+);
     return ;
 }