JoyOI1014 乘法游戏

最新推荐文章于 2021-03-22 19:47:49 发布

王20133

最新推荐文章于 2021-03-22 19:47:49 发布

阅读量547

点赞数

CC 4.0 BY-SA版权

分类专栏：动态规划 ACM 学习算法文章标签：动态规划 ACM 学习算法学习算法

本文链接：https://blog.youkuaiyun.com/u013862444/article/details/81416215

ACM 同时被 3 个专栏收录

71 篇文章

订阅专栏

学习算法

52 篇文章

订阅专栏

动态规划

24 篇文章

订阅专栏

本文介绍了一种通过动态规划解决乘法游戏问题的方法。玩家从一行包含正整数的牌中取牌，每次取牌得分为该牌数值与左右相邻牌数值的乘积。目标是最小化得分总和。

题目限制

时间限制	内存限制	评测方式	题目来源
1000ms	131072KiB	标准比较器	Local

题目背景

太原成成中学第2次模拟赛第四道

题目描述

乘法游戏是在一行牌上进行的。每一张牌包括了一个正整数。在每一个移动中，玩家拿出一张牌，得分是用它的数字乘以它左边和右边的数，所以不允许拿第1张和最后1张牌。最后一次移动后，这里只剩下两张牌。
    你的目标是使得分的和最小。
    例如，如果数是10 1 50 20 5，依次拿1、20、50，总分是                       10150+50205+10505=8000
    而拿50、20、1，总分是15020+1205+1015=1150。

输入格式

输入文件的第一行包括牌数(3<=n<=100)，第二行包括N个1-100的整数，用空格分开。

输出格式

输出文件只有一个数字：最小得分

样例数据

输入样例 #1	输出样例 #1
6 10 1 50 50 20 5	3650

一开始思考状态的时候，发现无论是先循环第几次取出的数还是先循环第几个数都有后效性。后来发现——最后一次取出的数肯定是sq[1]*sq[k]*sq[n]。正难则反，倒着搜索一下“倒数第k个数”就能水过了。
显然是划分区间的DP。假设k是最后一个数，那么倒数第二个数要么在(st, k)里面，要么在(k, ed)里面。为什么不是(k+1, ed)呢？
状态转移方程：
ret = min{ret, DFS(st, i) + DFS(i, ed) + sq[st] * sq[i] * sq[ed]}
递归的边界是只剩下两张牌，此时值应为0（无牌可取）

#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <cmath>
#include <stack>
#include <queue>
#include <vector>
#include <map>
#include <string>
#include <iostream>
using namespace std;
const int N = 105, SUP = 2e9;
int sq[N], n;
int d[N][N];
 
int DFS(int st, int ed)
{
	if(~d[st][ed])
		return d[st][ed];
	if(st+1 == ed)
		return 0;
	int ret = SUP;
	for(int i = st+1; i <= ed-1; i++)
		ret = min(ret, DFS(st, i) + DFS(i, ed) + sq[st] * sq[i] * sq[ed]);
	return d[st][ed] = ret;
}
 
int main()
{
	scanf("%d", &n);
	for(int i = 1; i <= n; i++)
		scanf("%d", &sq[i]);
	memset(d, -1, sizeof(d));
	printf("%d\n", DFS(1, n));
	return 0;
}

分析：枚举区间 [L,R ] 里那个数为最后留下来的数那么这个问题就会转换成 [L,i] [i,R] 的问题。

#include<iostream>
#include<stdio.h>
#include<string.h>
#include<algorithm>
#include<vector>
const int maxn = 200;
const int inf = 1e9;
typedef long long ll;
using namespace std;
int n,a[maxn+5],L[maxn+5],R[maxn+5];
int d[maxn][maxn];
int dp(int l,int r)
{
    if(d[l][r]!=-1) return d[l][r];
    if(l+1==r) return d[l][r] = 0;
    int ans = inf;
    for(int i=l+1;i<r;i++)
    {
        ans = min(ans,dp(l,i)+dp(i,r)+a[i]*a[l]*a[r]);
    }
    return d[l][r] = ans;
}
void solve()// 递归写法
{
    int ans = inf;
    memset(d,-1,sizeof(d));
    for(int i=2;i<n;i++)
    {
        ans = min(ans,dp(1,i)+dp(i,n)+a[i]*a[1]*a[n]);
    }
    printf("%d\n",ans);
}
void ok()// 递推写法
{
    memset(d,0,sizeof(d));
    for(int L=3;L<=n;L++)
    {
        for(int l=1;l+L-1<=n;l++)
        {
            int r = l+L-1;
            d[l][r] = inf;
            for(int j=l+1;j<r;j++)
            {
                d[l][r] = min(d[l][r],d[l][j]+d[j][r]+a[j]*a[l]*a[r]);
            }
        }
    }
    printf("%d\n",d[1][n]);
}
int main()
{
    while(~scanf("%d",&n))
    {
        for(int i=1;i<=n;i++) scanf("%d",&a[i]);
        //solve();
        ok();
    }
    return 0;
}

大牛：

用dp(l,r)表示将 l 到 r 移动到只剩两张卡片的最小分数
枚举区间内最后一张取出来的牌，则
dp(l,r)=min{dp(l,k)+dp(k,r)+al∗ak∗ar}
记忆化搜索

#include<cmath>
#include<cstdio>
#include<vector>
#include<cstring>
#include<algorithm>
#define inf 1000000000
using namespace std;
int n;
int a[105],f[105][105];
int dp(int l,int r)
{
    if(l+1==r)return 0;
    if(f[l][r]<inf)return f[l][r];
    for(int k=l+1;k<=r-1;k++)
        f[l][r]=min(f[l][r],dp(l,k)+dp(k,r)+a[l]*a[k]*a[r]);
    return f[l][r];
}
int main()
{
    memset(f,127,sizeof(f));
    scanf("%d",&n);
    for(int i=1;i<=n;i++)
        scanf("%d",&a[i]);
    printf("%d\n",dp(1,n));        
    return 0;    
}