Hdu 6188 Duizi and Shunzi【思维+Dp】

Duizi and Shunzi

Time Limit: 6000/3000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 357    Accepted Submission(s): 179

Problem Description

Nike likes playing cards and makes a problem of it.

Now give you n integers,  ai(1≤i≤n)

We define two identical numbers (eg:  2,2 ) a Duizi,
and three consecutive positive integers (eg:  2,3,4 ) a Shunzi.

Now you want to use these integers to form Shunzi and Duizi as many as possible.

Let s be the total number of the Shunzi and the Duizi you formed.

Try to calculate  max(s) .

Each number can be used only once.

 

Input

The input contains several test cases.

For each test case, the first line contains one integer n( 1≤n≤106 ). 
Then the next line contains n space-separated integers  ai  ( 1≤ai≤n )

 

Output

For each test case, output the answer in a line.

 

Sample Input

  
  

   
   7
1 2 3 4 5 6 7
9
1 1 1 2 2 2 3 3 3
6
2 2 3 3 3 3 
6
1 2 3 3 4 5
  
  

 

Sample Output

  
  

   
   2
4
3
2


   
   

    
    

     
     Hint
    
    


Case 1（1，2，3）（4，5，6）

Case 2（1，2，3）（1，1）（2，2）（3，3）

Case 3（2，2）（3，3）（3，3）

Case 4（1，2，3）（3，4，5）


   
   
  
  

题目大意：

给出N张牌，连续的三个数字的三张牌可以组成顺子，相同的两个数字组成对子。

问我们最多可以组成多少顺子和对子。

思路：

赛后百度了一波题解，发现大家都会贪心啊TAT：

①首先我们通过简单分析可以得到结论，如果三个连续的数字如果出现了多次。（222333444），我们一定是要先将其选对子，然后去选顺子。那么直接按照对子先选的顺序去贪心可以吗?显然是不行的，比如1 2 3 3 4 5这种，最优解是2，先选对子答案是1.

②那么如果满足上述条件的话，我们不难分析出，如果我们先将这些连续的出现多次的数先取了对子之后，每个数字作为一个顺子的部分的机会是很少的。我们通过简单分析得知，出现了4次就相当多了，反而多出现的顺子部分肯定要作为对子，所以4次肯定是一个可取的极限高度。

③那么我们设定Dp【i】【j】，表示我们以数字i结尾，并且以数字i结尾出现的顺子个数为j个的最优解。这里j最大取4~5其实就足够了。

那么其状态转移我们分成两种情况去走，一种是有重叠部分的去转移，一种是没有重叠部分去转移：

过程维护一下最优解即可，即ans=max（dp【i】【j】）；

时间复杂度O（n*4*4）

Ac代码：

#include <bits/stdc++.h>
typedef long long int LL;
int dp[1050000][5];
int have[1050000];
int max(int x,int y)
{
    if(x>y)return x;
    else return y;
}
int main()
{
    int n;
    while(~scanf("%d",&n))
    {
        memset(dp,0,sizeof(dp));
        memset(have,0,sizeof(have));
        for(int i=1;i<=n;i++)
        {
            int x;scanf("%d",&x);
            have[x]++;
        }
        int ans=0;
        for(int i=1;i<=n;i++)
        {
            for(int j=0;j<=4;j++)
            {
                for(int k=0;k<=4;k++)
                {
                    if(j==0)
                    dp[i][j]=max(dp[i][j],dp[i-1][k]+have[i]/2);
                    else
                    {
                        if(i-3>=0&&have[i]>=j&&have[i-1]>=j&&have[i-2]>=j)
                        {
                            dp[i][j]=max(dp[i][j],dp[i-3][k]+j+(have[i]-j)/2+(have[i-1]-j)/2+(have[i-2]-j)/2);
                        }
                        if(i-5>=0&&have[i]>=j&&have[i-1]>=j&&have[i-2]-k>=j)
                        {
                            dp[i][j]=max(dp[i][j],dp[i-2][k]+j-(have[i-2]-k)/2+(have[i]-j)/2+(have[i-1]-j)/2+(have[i-2]-j-k)/2);
                        }
                    }
                }
                ans=max(ans,dp[i][j]);
            }
        }
        printf("%d\n",ans);
    }
}