UVA 10118 Free Candies

最新推荐文章于 2019-04-11 22:13:56 发布
最新推荐文章于 2019-04-11 22:13:56 发布
阅读量97 收藏
点赞数
原文链接：http://www.cnblogs.com/JCRL/p/10109814.html
版权

传送门

题意翻译

桌上有4堆糖果，每堆有N（N≤40）颗。佳佳有一个最多可以装5颗糖的小篮子。他每次 选择一堆糖果，把最顶上的一颗拿到篮子里。如果篮子里有两颗颜色相同的糖果，佳佳就把 它们从篮子里拿出来放到自己的口袋里。如果篮子满了而里面又没有相同颜色的糖果，游戏 结束，口袋里的糖果就归他了。当然，如果佳佳足够聪明，他有可能把堆里的所有糖果都拿 走。为了拿到尽量多的糖果，佳佳该怎么做呢？

来自:刘汝佳《算法竞赛入门经典》

题目描述

PDF

输入输出格式

输入格式：

输出格式：

输入输出样例

输入样例#1： 复制 
5
1 2 3 4
1 5 6 7
2 3 3 3
4 9 8 6
8 7 2 1
1
1 2 3 4
3
1 2 3 4
5 6 7 8
1 2 3 4
0
输出样例#1： 复制 
8
0
3

 

#1:

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstdlib>
#include<cmath>
#include<cstring>
#define maxn 41
using namespace std;
int candy[5],n,l[5],dp[maxn][maxn][maxn][maxn],f[5][maxn],num;
int dfs(int Q,int num)
{    
    int a,b,c,d;
    if(l[1]==n||l[2]==n||l[3]==n||l[4]==n||num==5) 
    if(dp[l[1]][l[2]][l[3]][l[4]])
    return dp[l[1]][l[2]][l[3]][l[4]];
    for(int i=1;i<=4;i++)
    {
        if(l[i]<n) 
        {
        int j=1<<f[i][l[i]];
        l[i]++;
        if(Q&j)dp[l[1]][l[2]][l[3]][l[4]]=max(dp[l[1]][l[2]][l[3]][l[4]],dfs(Q-j,num-1)+1);
        else dp[l[1]][l[2]][l[3]][l[4]]=max(dp[l[1]][l[2]][l[3]][l[4]],dfs(Q+j,num+1)); 
        l[i]--;
        }
    } 
     return dp[l[1]][l[2]][l[3]][l[4]];
} 
int main()
{
    while(cin>>n&&n!=0)
    {
        memset(dp,0,sizeof dp);
        memset(l,0,sizeof l);
        for(int i=0;i<n;i++)
            for(int j=0;j<n;j++)
            cin>>f[j][i];
        cout<<dfs(0,0)<<endl;
    }
}

#2:

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstdlib>
#include<cmath>
#include<cstring>
#define maxn 41
using namespace std;
int candy[5],n,l[5],dp[maxn][maxn][maxn][maxn],f[5][maxn],num;
int dfs(int Q,int num)
{    
    int a,b,c,d;
    if(l[1]==n||l[2]==n||l[3]==n||l[4]==n||num==5) return 0;
    if(dp[l[1]][l[2]][l[3]][l[4]])
    return dp[l[1]][l[2]][l[3]][l[4]];
    for(int i=1;i<=4;i++)
    {
        if(l[i]<n) 
        {
        int j=1<<f[i][l[i]];
        l[i]++;
        if(Q&j)dp[l[1]][l[2]][l[3]][l[4]]=max(dp[l[1]][l[2]][l[3]][l[4]],dfs(Q-j,num-1)+1);
        else dp[l[1]][l[2]][l[3]][l[4]]=max(dp[l[1]][l[2]][l[3]][l[4]],dfs(Q+j,num+1)); 
        l[i]--;
        }
    } 
     return dp[l[1]][l[2]][l[3]][l[4]];
} 
int main()
{
    while(cin>>n)
    {
        if(n==0)break;
        memset(dp,0,sizeof dp);
        memset(l,0,sizeof l);
        for(int i=0;i<4;i++)
            for(int j=0;j<n;j++)
            cin>>f[i][j];
        cout<<dfs(0,0)<<endl;
    }
}

#3:

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstdlib>
#include<cmath>
#include<cstring>
#define maxn 41
using namespace std;
int n,l[5],dp[maxn][maxn][maxn][maxn],f[5][maxn];
int dfs(int Q,int num)
{    
    if(l[1]==n&&l[2]==n&&l[3]==n&&l[4]==n&&num==5) return dp[l[1]][l[2]][l[3]][l[4]]=0;
    if(dp[l[1]][l[2]][l[3]][l[4]])
    return dp[l[1]][l[2]][l[3]][l[4]];
    for(int i=0;i<4;i++)
    {
        if(l[i]<n) 
        {
        int j=1<<f[i][l[i]];
        l[i]++;
        if(Q&j)dp[l[1]][l[2]][l[3]][l[4]]=max(dp[l[1]][l[2]][l[3]][l[4]],dfs(Q-j,num-1)+1);
        else if(num<5)dp[l[1]][l[2]][l[3]][l[4]]=max(dp[l[1]][l[2]][l[3]][l[4]],dfs(Q+j,num+1)); 
        l[i]--;
        }
    } 
     return dp[l[1]][l[2]][l[3]][l[4]];
} 
int main()
{
    while(cin>>n)
    {
        if(n==0)break;
        memset(dp,0,sizeof dp);
        memset(l,0,sizeof l);
        for(int i=0;i<4;i++)
            for(int j=0;j<n;j++)
            cin>>f[i][j];
        cout<<dfs(0,0)<<endl;
    }
}

#4：

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstdlib>
#include<cmath>
#include<cstring>
#define maxn 41
using namespace std;
int n,l[5],dp[maxn][maxn][maxn][maxn],f[maxn][5];
int dfs(int Q,int num)
{    
    if(dp[l[0]][l[1]][l[2]][l[3]]!=-1)
    return dp[l[0]][l[1]][l[2]][l[3]];        
    if((l[0]==n&&l[1]==n&&l[2]==n&&l[3]==n)||num==5) return dp[l[0]][l[1]][l[2]][l[3]]=0;
    for(int i=0;i<4;i++)    
    {
        if(l[i]<n) 
        {
        int j=1<<f[l[i]][i];
        l[i]++;
        if(j&Q)dp[l[0]][l[1]][l[2]][l[3]]=max(dp[l[0]][l[1]][l[2]][l[3]],dfs(Q-j,num-1)+1);
        else if(num<5)dp[l[0]][l[1]][l[2]][l[3]]=max(dp[l[0]][l[1]][l[2]][l[3]],dfs(Q+j,num+1)); 
        l[i]--;
        }
    } 
     return dp[l[0]][l[1]][l[2]][l[3]];
} 
int main()
{
    while(cin>>n)
    {
        if(n==0)break;
        memset(dp,-1,sizeof dp);
        memset(l,0,sizeof l);
        for(int i=0;i<n;i++)
            for(int j=0;j<4;j++)
            cin>>f[i][j];
        cout<<dfs(0,0)<<endl;
    }
}

 #5：

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstdlib>
#include<cmath>
#include<cstring>
#define maxn 41
using namespace std;
int n,l[5],dp[maxn][maxn][maxn][maxn],f[maxn][5];
int dfs(int Q,int num)
{    
    if(dp[l[0]][l[1]][l[2]][l[3]]!=-1)
    return dp[l[0]][l[1]][l[2]][l[3]];        
    if((l[0]==n&&l[1]==n&&l[2]==n&&l[3]==n)||num==5) return dp[l[0]][l[1]][l[2]][l[3]]=0;
    for(int i=0;i<4;i++)    
    {
        if(l[i]<n)
        {
        int j=1<<f[l[i]][i];
        l[i]++;
        if(j&Q)dp[l[0]][l[1]][l[2]][l[3]]=max(dp[l[0]][l[1]][l[2]][l[3]],dfs(Q-j,num-1)+1);
        else if(num<5)dp[l[0]][l[1]][l[2]][l[3]]=max(dp[l[0]][l[1]][l[2]][l[3]],dfs(Q+j,num+1));
        l[i]--;
        }
    }
     return dp[l[0]][l[1]][l[2]][l[3]];
}
int main()
{
    while(cin>>n)
    {
        if(n==0)break;
        memset(dp,-1,sizeof dp);
        memset(l,0,sizeof l);
        for(int i=0;i<n;i++)
            for(int j=0;j<4;j++)
            cin>>f[i][j];
        cout<<dfs(0,0)<<endl;
    }
}

AC代码：

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstdlib>
#include<cmath>
#include<cstring>
#define maxn 41
using namespace std;
int n,l[5],dp[maxn][maxn][maxn][maxn],f[maxn][5];
int dfs(int Q,int num)
{   
    int &now=dp[l[0]][l[1]][l[2]][l[3]];
    if(now!=-1)
    return now;      
    if((l[0]==n&&l[1]==n&&l[2]==n&&l[3]==n)||num==5) return now=0;
    for(int i=0;i<4;i++)    
    {
        if(l[i]<n) 
        {
        int j=1<<f[l[i]][i];
        l[i]++;
        if(j&Q)now=max(now,dfs(Q-j,num-1)+1);
        else if(num<5)now=max(now,dfs(Q+j,num+1)); 
        l[i]--;
        }
    } 
     return now;
} 
int main()
{
    while(1)
    {
        cin>>n;
        if(n==0)break;
        memset(dp,-1,sizeof dp);
        memset(l,0,sizeof l);
        for(int i=0;i<n;i++)
            for(int j=0;j<4;j++)
            cin>>f[i][j];
        cout<<dfs(0,0)<<endl;
    }
}

 很好奇为什么#5和AC代码就是换了个名字答案却不一样。

转载于:https://www.cnblogs.com/JCRL/p/10109814.html

weixin_34406061
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
UVa 10118 记忆化搜索 Free Candies
weixin_30354675的博客
09-01 87
假设在当前状态我们第i堆糖果分别取了cnt[i]个，那么篮子里以及口袋里糖果的个数都是可以确定下来的。 所以就可以使用记忆化搜索。 1 #include <cstdio> 2 #include <cstring> 3 #include <algorithm> 4 using namespace std; 5 6 const i...
【Uva 10118】Free Candies
10-04 90
【Link】: 【Description】 有4堆书; 每本书编号从1..20 每堆书都是N本; 然后每次只能从任意一堆的堆顶拿一本书装到自己的口袋里; 你的口袋最多容纳5本书; 当你的口袋里有两本一样的书的时候,那一对书就归你了; 但是一旦你的口袋装满了,就不能再装书了;游戏停止 问你最多能拿多少对书。 【Solution】 比较明显...
uva 10118 ——Free Candies
坚持不懈
12-06 480
题意：桌子上有4 堆糖果，要从这四堆糖果中取出5个，如果5个中有相同的颜色则把他们拿出来放到口袋，求最多放多少糖果。 思路：DAG最长路问题。需要把问题转化成DAG的问题，以个数作为转移的状态，当达到5的时候为0，否则就是选当前的和不选当前的最大值。 code： #include using namespace std; using namespace std; typ
uva 10118 记忆化搜索
Dikea's Blog
08-10 860
Little Bob is playing a game. He wants to win some candies in it - as many as possible. There are 4 piles, each pile contains N candies. Bob is given a basket which can hold at most 5 candies. Each
UVA：10118 Free Candies
宴夜小丑的博客
05-27 256
题目链接题目大意：      有4堆糖果，每一堆有n个糖果，有一个篮子，这个篮子的最大容量为5块糖，每一次从这四堆中选择一堆，然后将最上面的糖果拿下来，放到篮子里面去，如果有相同两块糖的就把这；两块糖拿出来，如果达到了5块糖，并且这5块糖是两两不相同的就结束游戏，问你，最多能拿出多少对糖动态规划，状态为篮子里的糖果数，用k1 k2 k3 k4代表每堆糖的高度，即4维矩阵进行存储，代表此时糖堆的状态...
PWA_Candies
03-13
**PWA_Candies: 通往更甜美的渐进式Web应用之旅** PWA（Progressive Web App）是一种新兴的Web开发技术，旨在提供接近原生应用体验的网页应用。"PWA_Candies"很可能是一个项目或者教程，旨在通过一系列实例来展示...
candies_ranked
02-18
糖果排名：哪种甜品至高无上？ 根据类型，价格，糖水平和受欢迎程度对各种糖果和巧克力进行的数据分析 由Sanjana Melkote 我最近决定开始饮食健康，避免食用所有加工食品和加糖。 当然，在做出这一决定后，我发现了...
Java Candies-开源
07-05
一个 Java 1.1 GUI 组件库，用于制作具有很多视觉效果和价值的界面。 图像按钮、动画复选框、标签文件夹、日期选择器。
flutter_candies:自定义颤动糖果（小部件），让您轻松构建颤动应用程序，尽情享受
04-28
扑 自定义颤动糖果（小部件），让您轻松构建颤动应用程序，尽情享受 Flutter网格视图易于快速建立瀑布流布局。 Like Button是一个颤动的库，当您喜欢某些东西时，它允许您创建具有类似于Twitter心脏动画效果的...
candies-paypal:PayPal Java REST SDK 和 MQTT 集成示例
07-11
标题“candies-paypal:PayPal Java REST SDK 和 MQTT 集成示例”表明这是一个关于将 PayPal 的 Java RESTful（Representational State Transfer）软件开发工具包（SDK）与 MQTT（Message Queuing Telemetry ...
UVA - 10118 Free Candies 记忆化搜索
静静地码
11-27 1274
题目大意：有4堆糖果，每堆有N个，糖果的话只能从上往下取，每个糖果都有颜色，有一个篮子，最多只能装5个，如果篮子中有颜色2个颜色相同的糖果的话，就可以把这两个颜色相同的糖果拿出来，问最多能得到多少对糖果 解题大意:用一个四维数组来表示状态，dp[i][j][k][l],i,j,k,l表示4堆糖果分别拿到i,j,k,l这个位置最多可以得到多少对糖果，再用一个hash数组表示各种颜色的糖果是否能成对
【记忆化搜索】UVA 10118 free candy
iroy33的博客
04-11 147
题意：有四根管道，每根里面有n颗糖，每次只能从管道的最上面拿糖进篮子里。如果篮子里面有两颗颜色一样的糖（数值大小一样），那么Bob可以将这两颗糖揣进自己的口袋里，如果篮子里的糖数为5颗，就结束。问Bob最多能拿到几颗糖 思路：将每根管道拿出的糖数num[1],num[2],num[3],num[4]作为一种状态,求解该状态下还能拿多少颗糖 留了一个疑惑在返回和输出的地方_(:з」∠)_ #...
UVA 10118 - Free Candies(记忆化搜索)
L.
06-28 345
原题链接 用k[1]到k[4]表示四堆糖果的高度.用dp[k[1]][k[2]][k[3]][k[4]]表示这个高度下能够获得多少多少糖果,记忆化搜索. #include #include #include #include #define INF 1e9 using namespace std; int dp[45][45][45][45]; int num[5][45], vis
UVa 10118 免费糖果（记忆化搜索+哈希）
weixin_30415801的博客
02-08 98
https://vjudge.net/problem/UVA-10118 题意： 桌上有4堆糖果，每堆有N颗。佳佳有一个最多可以装5颗糖的小篮子。他每次选择一堆糖果，把最顶上的一颗拿到篮子里。如果篮子里有两颗颜色相同的糖果，佳佳就把它们从篮子里拿出来放到自己的口袋里。如果篮子满了而里面又没有相同颜色的糖果，游戏结束。 思路： 怎么判断糖果是否颜色相同是本题的一个重点，看了别人的思路后...
【UVa】【DP】10118 Free Candies
IDDFS
08-09 207
UVa 10118 Free Candies 题目 ◇题目传送门◆ 题目大意 桌上有4堆糖果，每堆有N(N≤40)N(N≤40)N(N\le40)颗，每颗糖都有一个颜色，共有20种颜色。Bob有一个能装5个糖的篮子，他每次可以从任意一堆糖中取出最顶上的一颗，若篮子中有两个糖颜色相同，他就会将它们从篮子中取出放到自己的袋子里，若篮子装满了且里面没有相同颜色的糖，则停止取糖，Bo...
uva10118
不努力只能看别人脸色。
03-03 619
题目大意： 有4堆糖果，每堆有n（最多40）个，有一个篮子，最多装5个糖果，我们每次只能从某一堆糖果里拿出一个糖果，如果篮子里有两个相同的糖果，那么就可以把这两个（一对）糖果放进自己的口袋里，问最多能拿走多少对糖果。糖果种类最多20种. 思路： 记忆化搜索 用一个h数组来记录在此之前是否有一个单独的糖果i,如果有h数组中的此位置就变成0，如果没有就为1。然后不断的搜索。知道篮子中有5个糖果或者
UVA - 10118 Free Candies(免费糖果)(dp---记忆化搜索)
Cherrychan2014的博客
02-22 191
题意：桌上有4堆糖果，每堆有N(N<=40)颗。佳佳有一个最多可以装5颗糖的小篮子。他每次选择一堆糖果，把最顶上的一颗拿到篮子里。如果篮子里有两颗颜色相同的糖果，佳佳就把它们从篮子里拿出来放到自己的口袋里。如果篮子满了而里面又没有相同颜色的糖果，游戏结束，口袋里的糖果就归他了。问最多能拿到多少对糖果。 分析： 1、dp[a][b][c][d]表示，当4堆糖果分别剩下a，b，c，...
习题9-2（免费糖果）【深搜dfs】+【记忆化搜索】
orzAC--算法代码园
01-25 495
习题9-2【UVa 10118】Free Candies（免费糖果）题目大意：桌上有4堆糖果，每堆有N(N<=40)颗。佳佳有个最多可以装5颗糖果的小篮子。他每次选择一堆糖果，把最顶上的一颗拿到篮子里。如果篮子里有两颗颜色相同的糖果，佳佳就把他们从篮子里拿出来放到自己口袋里。如果篮子满了而里面又没有相同颜色的糖果，游戏结束，口袋里的糖果就归他了。当然，如果佳佳够聪明，他有可能把堆里的所有糖果都拿走。
7.15 陇东学院云计算1班 马陆辉 20240715
最新发布
07-15
练习题
import sys def divide(candies, count, minCount): if candies == 1: minCount[0] = min(minCount[0], count) return if candies % 2 == 0: divide(candies // 2, count + 1, minCount) else: divide(candies + 1, count + 1, minCount) divide(candies - 1, count + 1, minCount) candies = int(input()) minCount = [sys.maxsize] divide(candies, 0, minCount) print(minCount[0])为什么这个程序输入47得到的结果是7呢？
07-15
这段程序的目的是计算将糖果均分给两个人所需的最小操作次数。让我们来分析一下为什么输入47会得到7作为结果。 当输入为47时，程序通过递归调用 `divide(candies, count, minCount)` 进行计算。初始调用是 `divide(47, 0, minCount)`。 首先，程序检查是否只剩下一个糖果。由于47不等于1，所以不满足条件。 接下来，程序检查47是否为偶数。由于47不是偶数，所以执行 `else` 分支。 在 `else` 分支中，程序进行了两个递归调用： 1. `divide(candies + 1, count + 1, minCount)`：这是将糖果数量加1的操作，并将操作次数加1。 2. `divide(candies - 1, count + 1, minCount)`：这是将糖果数量减1的操作，并将操作次数加1。 这两个递归调用会产生分支，并继续递归地进行计算。 对于第一个递归调用 `divide(candies + 1, count + 1, minCount)`，它会将糖果数量从47增加到48，并将操作次数从0增加到1。 接着，程序继续递归调用 `divide(candies // 2, count + 1, minCount)`，此时糖果数量为48。由于48是偶数，程序执行 `divide(candies // 2, count + 1, minCount)`，将糖果数量除以2，并将操作次数加1。 然后，程序继续递归调用 `divide(candies // 2, count + 1, minCount)`，此时糖果数量为24。同样地，程序将糖果数量除以2，并将操作次数加1。 接下来，程序继续递归调用 `divide(candies // 2, count + 1, minCount)`，此时糖果数量为12。同样地，程序将糖果数量除以2，并将操作次数加1。 继续递归调用 `divide(candies // 2, count + 1, minCount)`，此时糖果数量为6。同样地，程序将糖果数量除以2，并将操作次数加1。 接下来，程序继续递归调用 `divide(candies // 2, count + 1, minCount)`，此时糖果数量为3。由于3是奇数，程序将糖果数量加1，并将操作次数加1。 然后，程序继续递归调用 `divide(candies // 2, count + 1, minCount)`，此时糖果数量为4。同样地，程序将糖果数量除以2，并将操作次数加1。 最后，程序继续递归调用 `divide(candies // 2, count + 1, minCount)`，此时糖果数量为2。同样地，程序将糖果数量除以2，并将操作次数加1。 此时，糖果数量变为1，满足终止条件。程序将当前的操作次数1与 `minCount[0]` 中的值进行比较，并将较小值更新到 `minCount[0]` 中。 综上所述，最小操作次数为7。因此，输入47得到的结果是7。 如果你有任何其他问题，请告诉我。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值