牛客刷题记录4

1.凸多边形的划分

思路：和上一篇的那个差不多 也是区间dp 但是长度要从3开始枚举 因为三角形最少三个点

然后这题数据比较大 所以要用高精度

 

 无高精度代码

#include <bits/stdc++.h>
using namespace std;
const int N=210;
int w[N],f[N][N];
int main()
{
    int n;
    cin>>n;
    for(int i=1;i<=n;i++) cin>>w[i];
    for(int len=3;len<=n;len++)
        for(int l=1;l+len-1<=n;l++)
        {
            int r=len+l-1;
            f[l][r]=0x3f3f3f3f;
            for(int k=l+1;k<r;k++)
                f[l][r]=min(f[l][r],f[l][k]+f[k][r]+w[l]*w[k]*w[r]);
        }
    cout<<f[1][n]<<endl;
    return 0;
}

AC代码

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N=55,M=35;
ll w[N],f[N][N][M];//第三维记录数的大小

void add(ll a[],ll b[])//高精度加法
{
    static ll c[M];
    memset(c,0,sizeof c);
    ll t=0;
    for(int i=0;i<M;i++)
    {
        t+=a[i]+b[i];
        c[i]=t%10;
        t/=10;
    }
    memcpy(a,c,sizeof c);
}
void mul(ll a[],ll b)//高精度乘法
{
    static ll c[M];
    memset(c,0,sizeof c);
    ll t=0;
    for(int i=0;i<M;i++)
    {
        t+=a[i]*b;
        c[i]=t%10;
        t/=10;
    }
    memcpy(a,c,sizeof c);
}
bool cmp(ll a[],ll b[])//比较两个数的大小
{
    for(int i=M-1;i>=0;i--)
        if(a[i]>b[i]) return true;
        else if(a[i]<b[i]) return false;
    return false;
}
void print(ll a[])//用来输出答案
{
    int k=M-1;
    while(k&&!a[k]) k--;
    while(k>=0) cout<<a[k--];
    cout<<endl;
}

int main()
{
    int n;
    cin>>n;
    for(int i=1;i<=n;i++) cin>>w[i];
    ll temp[M];
    for(int len=3;len<=n;len++)
        for(int l=1;l+len-1<=n;l++)
        {
            int r=len+l-1;
            f[l][r][M-1]=1;//最高位是1 所以是初始化为最大值
            for(int k=l+1;k<r;k++)
            {
                //f[l][r]=min(f[l][r],f[l][k]+f[k][r]+w[l]*w[k]*w[r]);
                memset(temp,0,sizeof temp);//清空上一次的数组
                temp[0]=w[l];
                mul(temp,w[k]);
                mul(temp,w[r]);
                add(temp,f[l][k]);
                add(temp,f[k][r]);
                if(cmp(f[l][r],temp))
                    memcpy(f[l][r],temp,sizeof temp);
            }
        }
    print(f[1][n]);
    return 0;
}

2.田忌赛马

思路：这题好像可以用区间dp 但是这里我用了贪心（不知道怎么用区间dp）

首先第一步肯定是把双方的马都排序,然后先把最慢的马比一下,如果这马比国王快,直接赢下来,如果比国王慢那就用这匹马输给国王最快的马(反正都要输,尽量消耗他);

但是如果一样快,就要比较最快的那匹马,如果最快的那匹马比较快,也是直接赢下来,然后比较接下去最快的,如果最快的马小于或等于国王的,那就用慢的那匹去输(因为如果直接快对快,慢对慢,那么就是一平一负,用慢对快,就是那一负,但是快的那匹肯定会多赢一场下来,收获是一样的,但是这样做我们留下的一匹快的,对方留下一只慢的,后面可以做更好的安排)(如果快马也等于快马也是一样,把两平,换成一胜一负)原文：uvalive3266(田忌赛马)_二分查找的博客-CSDN博客

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;

const int N = 1005;
int tian[N], king[N], n;

int main() {
	scanf("%d",&n);
    for(int i = 0; i < n; i++){
        scanf("%d",&tian[i]);
    }
    for(int i = 0; i < n; i++){
        scanf("%d",&king[i]);
    }
    sort(tian, tian + n);
    sort(king, king + n);
    int sum = 0, tf = 0, kf = 0, tb = n - 1, kb = n - 1;
    while(tf <= tb) {
        if(tian[tf] > king[kf]) {
            sum += 200;
            tf++;
            kf++;
            continue;
        }
        if(tian[tf] < king[kf]) {
            sum -= 200;
            tf++;
            kb--;
            continue;
        }
        if(tian[tf] == king[kf]) {
            if(tian[tb] > king[kb]) {
					sum += 200;
                tb--;
                kb--;
                continue;
            }
            if(tian[tb] <= king[kb]) {
                if(tian[tf] < king[kb])
                    sum -= 200;
                tf++;
                kb--;
                continue;
            }
        }
    }
    printf("%d\n",sum);
}

3.合并回文子串

3.1前置小题

给出一个字符串S，求S的最长回文子串的长度。

字符串"PATZJUJZTACCBCC"的最长回文子串为"ATZJUJZTA",长度为9。

小题解法

dp

 状态定义为dp[ i ][ j ]为从i点开始到 j 点是否是回文串 那么如果说开始点s[i]==s[j](结束点)那么这个串就有可能是回文串了 那么如果说 dp[i+1][j-1]是回文串 那么这个串肯定是回文串 如果s[i] != s[j]那么肯定不是回文串

初始化时只有dp[i][i]=1 从 i 到 i 只有一个点 那一定是回文串 

如果s[i]==s[i+1]时 dp[i][i+1]=1 为什么要初始化长度为2的串呢

因为如果长度是2的话 就会更新从状态dp[i+1][j-1]更新 就好像abba 长度为2是bb是符合的 那么会从dp[2][1]更新dp[1][2]显然是不行的 那么我们就需要把长度为2的也初始化了

引用

小题代码

#include <bits/stdc++.h>
using namespace std;
const int maxn=1000;
char S[maxn];//A存序列，dp[i]存以i为结尾的连续序列的最大和
int dp[maxn][maxn];
int main()
{
	gets(S);//从下标为1开始读入
	int len=strlen(S),ans=1;
	memset(dp,0,sizeof(dp));
	for(int i=0;i<len;i++)
	{
		dp[i][i]=1;
		if(i<len-1)
		{
			if(S[i]==S[i+1])
				{
					dp[i][i+1]=1;
					ans=2;//初始化时注意当前最长回文子串长度；
				}
		}
	}
	//状态转移方程
	for(int L=3;L<=len;L++)//枚举子串长度
		for(int i=0;i+L-1<len;i++)//枚举子串起始端点 起始端点加上子串长度(子串长度包括他
			{
				int j=i+L-1;//子串右端点
				cout<<L<<" "<<S[i]<<" "<<S[j]<<endl;
				if(S[i]==S[j]&&dp[i+1][j-1]==1)
				{
					dp[i][j]=1;
					ans=L;//更新最长回文子串长度;
				}
			}
		cout<<ans<<endl;
}

那么回到大题

那么大题也和小题差不多了 只是状态多了点而已

    dp[sa][ea][sb][eb]=0;
    if(a[sa]==a[ea]) dp[sa][ea][sb][eb]|=dp[sa+1][ea-1][sb][eb];
    if(b[sb]==b[eb]) dp[sa][ea][sb][eb]|=dp[sa][ea][sb+1][eb-1];
    if(a[sa]==b[eb]) dp[sa][ea][sb][eb]|=dp[sa+1][ea][sb][eb-1];
    if(a[ea]==b[sb]) dp[sa][ea][sb][eb]|=dp[sa][ea-1][sb+1][eb];

 初始化 dp[1][1][0][0]=1和dp[0][0][1][1]=1; 可以想一下

#include <bits/stdc++.h>
using namespace std;
const int N=55;
bool f[N][N][N][N];
char a[N],b[N];
int main()
{
    int t;
    cin>>t;
    while(t--)
    {
        cin>>a+1>>b+1;
        int maxl=-0x3f3f3f3f;
        int lena=strlen(a+1),lenb=strlen(b+1);
        for(int la=1;la<=lena;la++)
            for(int lb=1;lb<=lenb;lb++)
                for(int sa=1;sa+la-1<=lena;sa++)
                    for(int sb=1;sb+lb-1<=lenb;sb++)
                    {
                         int ea=sa+la-1,eb=sb+lb-1;
                         if(la+lb<=1) f[sa][ea][sb][eb]=1;
                         else
                         {
                            f[sa][ea][sb][eb]=0;
                            if(a[sa]==a[ea]) f[sa][ea][sb][eb]|=f[sa+1][ea-1][sb][eb];
                            if(b[sb]==b[eb]) f[sa][ea][sb][eb]|=f[sa][ea][sb+1][eb-1];
                            if(a[sa]==b[eb]) f[sa][ea][sb][eb]|=f[sa+1][ea][sb][eb-1];
                            if(a[ea]==b[sb]) f[sa][ea][sb][eb]|=f[sa][ea-1][sb+1][eb];
                         }
                         if(f[sa][ea][sb][eb]) maxl=max(maxl,la+lb);
                    }
        printf("%d\n",maxl);
    }
    return 0;
}