hdu 3998 (最长上升子序列+最大流)

 

题意 ： 有一个数组，求这个数组的最长上升子序列有多少种；每个数字只能用一次，即一个数字只能算其中的一种；

思路：思路跟最短路径+最大流是一样的，用最大流去限定，求出最短路径的个数。同样，求出最长上升子序列，再用最大流去限定，求出的结果就是最长上升子序列的个数。求LCIS则用常规方法，既定义数组dp[i]是表示以 i 结尾的最长上升子序列的长度，求出最长序列ans。由于数列中的每一个数只能使用一次，构图的时候需要拆点。若有n个数，则拆成2 * n个点，构造源点和汇点，将每个点都和自己拆出来的点连边，将源点和最长序列为1的点连边，将最长序列为ans的点与汇点连边，最后若dp[j] = dp[i] + 1,则将i + n和 j连边。所有边的流量都是1，这样便可以限制每个点只使用一次。其实连边的顺序就是最长序列为1，2，3，...，ans。可以理解为从最长序列为1（该数本身）一直流到数列中的最长上升序列。画出图来就好理解了

 

#include<cstdio>
#include<cstring>
#include<map>
#include<vector>
#include<cmath>
#include<cstdlib>
#include<stack>
#include<queue>
#include <iomanip>
#include<iostream>
#include<algorithm>
using namespace std ;
const int  N=8888 ;
const int inf = 0xfffffff ;
struct node
{
    int u,v,next,c;
}edge[N*88] ;
int head[N],pre[N],gap[N],dis[N],d[N],cur[N] ,x[N];
int top ,s,t,vn,n ;

void add(int u ,int v,int c)
{
    edge[top].u=u;
    edge[top].v=v;
    edge[top].c=c;
    edge[top].next=head[u];
    head[u]=top++;
   
    edge[top].u=v;
    edge[top].v=u;
    edge[top].c=0;
    edge[top].next=head[v];
    head[v]=top++;
}

int  LCIS()                        //最长上升子序列
{
     for(int i = 1 ; i <= n ;i++)
            d[i]=1;
      for(int i = 1 ; i <= n ; i++)
        for(int j= 1 ;j < i ; j++)
          {
                if(x[i]>x[j] && d[j]+1 > d[i])   //d[j]+1 > d[i]，才更新，
                  d[i] = d[j]+1 ;
          }     
  int ans=0;
     for(int i = 1 ; i <= n ; i++)
        ans = max(ans,d[i]) ;
   return ans ;                 
}

 int max_flow()
 {
      memset(pre,-1,sizeof(pre));
      memset(dis,0,sizeof(dis));
      memset(gap,0,sizeof(gap));
      int id,u=s,v,nect,cur_flow,mindis,Max_flow=0,i;
      gap[0]=vn;
      //pre[s]=s;
      for( i = 0 ; i < vn ; i++)  cur[i]=head[i] ;
      while(dis[s] < vn)
      {
                 if(u==t)
                  {
                         cur_flow=inf ;
                         for( i = s ; i != t ; i=edge[cur[i]].v)
                         {
                                 if(  edge[cur[i]].c < cur_flow)
                                 {
                                      cur_flow = edge[cur[i]].c;
                                      nect = i ;
                                 }
                         }
                         for( i = s ; i != t ; i=edge[cur[i]].v)
                         {
                                 id =cur[i] ;
                                 edge[id].c -=cur_flow ;
                                 edge[id^1].c +=cur_flow ;
                         }
                         Max_flow += cur_flow ;
                         u=nect ;
                  }
                 for( i = cur[u] ; i!=-1 ;i=edge[i].next)
                 {
                          v=edge[i].v;
                     if(edge[i].c>0 && dis[u]==dis[v]+1 )
                        break ;     
                 }
                 if(i!=-1)
                 {
                        pre[v]=u;
                        cur[u]=i;
                        u=v;
                 }
                 else
                 {
                         if(--gap[dis[u]]==0)  break;
                          cur[u]=head[u];
                          mindis=vn;
                          for( i = cur[u] ; i!=-1 ;i=edge[i].next)
                         {
                              v=edge[i].v;
                              if(edge[i].c>0 && dis[v]<mindis)
                              {
                                      mindis=dis[v];
                                      cur[u]=i;
                              }
                         } 
                         dis[u]=mindis+1;
                         gap[dis[u]]++;
                         if(u!=s) u=pre[u];
                 }
      }
       return Max_flow ;
 }
 
int main()
{
     while(~scanf("%d",&n))
     {
         for(int i = 1 ; i <= n ;i++)
            scanf("%d",&x[i]);
          int ans = LCIS() ;
         top=0;
         memset(head,-1,sizeof(head));
         s=0;t=2*n+1;vn=t+1;
         for(int i = 1 ; i <= n ;i++) 
          {
                 add(i,i+n,1);         //拆点，亮点连边
                 if(d[i]==1)
                    add(s,i,1);        //与源点连
                 if(d[i]==ans)   //只有长度为最长子序列，才与汇点相连，保证了，最后流到汇点的就是符合的个数；
                   add(i+n,t,1);
                 for(int j = i+1 ; j <= n ;j++  )    //j跟在i后面组成的序列，长度为d[j];
                  if(d[j]==d[i]+1)
                      add(i+n,j,1) ; 
          }
          int num = max_flow() ;              //跑一边最大流；
          printf("%d\n%d\n",ans,num);
     }
      return 0;
}