Hdu 6188 Duizi and Shunzi【思维+Dp】

最新推荐文章于 2018-07-23 11:42:11 发布

原创最新推荐文章于 2018-07-23 11:42:11 发布 · 573 阅读

1 ·

本内容遵循CC 4.0 BY-SA版权协议

标签

#Hdu 6188

思维同时被 2 个专栏收录

692 篇文章

订阅专栏

351 篇文章

订阅专栏

本文探讨了一种牌类游戏中的算法优化策略，旨在通过合理的组合方式最大化顺子和对子的数量。采用动态规划方法，结合贪心策略实现最优解。

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);
    }
}