2021-3-12 大二周赛题解_codeforces1100分什么水平-优快云博客

本文链接：https://blog.youkuaiyun.com/weixin_45235164/article/details/114702749

A - 思维题

本题不难，codeforces评级只有1100分。思维题，关键在于将T-array[i]和arrary[i]分组考虑，而当arrary[i]*2==T时，将平均分配至两组为最优解。
用map以及标记数组简单实现即可

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
map<int, int>m, vis;
const int N = 100005;
int ar[N];
int ans[N];
int main()
{
    int t, i, j, n, T;
    cin >> t;
    while (t--)
    {
        cin >> n >> T;
        int flag = 0;
        for (i = 1; i <= n; i++)
        {
            cin >> ar[i];
            m[ar[i]] = i;//记录数组元素出现的对应下标
        }
        for (i = 1; i <= n; i++)
        {
            //如果T-ar[i]出现在数组里时，需要将T-ar[i]和ar[i]分开考虑,并将T-ar[i]的位置标记
            //否则遍历到T-ar[i]元素值的时候会重复触发。
            //ar[i]*2==T的情况单独判断，最优情况是平均分在两个不同的组里
            if (m[T - ar[i]] != 0 && vis[ar[i]] == 0 && ar[i] * 2 != T)
            {
                ans[i] = 1;
                vis[T - ar[i]] = 1;
            }
        }
        for (i = 1; i <= n; i++)
        {
            if (ar[i] * 2 != T)
                cout << ans[i] << ' ';
            else
                cout << (flag % 2 ? 1 : 0) << ' ', flag++;
            if (ans[i] == 1)
                ans[i] = 0;
        }
        cout << endl;
        vis.clear();
        m.clear();
    }
    return 0;
}

B - dp签到题1

签到题，但没想到过的人就两个。三种硬币三次刷新dp数组即可。

<<<题目链接>>>

#include<bits/stdc++.h>
using namespace std;
int dp[33770];
int main()
{
	int n, i, j;
	dp[0] = 1;
	for (i = 1; i <= 3; i++)
	{
		for (j = i; j <= 32770; j++)
		{
			dp[j] += dp[j - i];
		}
	}
	while (cin >> n)
	{
		cout << dp[n] << endl;
	}
	return 0;
}

C - 最长公共子序列（LCS）

<<<题目链接>>>

设a,b为两个长度不同的字符串，dp[i][j]为长度为i和长度为j的字符串的最长公共子序列长度。

先考虑状态转移方程

当a_n = b_m时，有 $d p [i] [j] = d p [i - 1] [j - 1] + 1$
因为最后一位必定是最长公共子序列的最后一位（~~都相等了怎么可能不是~~ )

当a_n ≠ b_m时，有 $d p [i] [j] =$ max{ $d p [i - 1] [j], d p [i] [j - 1]$ }

循环填表即可，注意数组下标的起始条件，不要出现负数越界了！

#include<bits/stdc++.h>
typedef long long ll;
using namespace std;
int dp[1002][1002];
string s1, s2;
int main()
{
	int i, j, n;
	while (cin >> s1 >> s2)
	{
		memset(dp, 0, sizeof(dp));
		for (i = 0; i < s1.size(); i++)
		{
			for (j = 0; j < s2.size(); j++)
			{
				if (s1[i] == s2[j])
				{
					dp[i+1][j+1] = dp[i][j] + 1;
				}
				else
				{
					dp[i+1][j+1] = max(dp[i][j+1], dp[i+1][j]);
				}
			}
		}
		int n = s1.size(), m = s2.size();
		cout << dp[n][m] << endl;
	}
	return 0;
}

D - dp签到题2

<<<题目链接>>>

又是一道签到题，这道题以前大一上学期就做过了，放到周赛当做签到题，就当热身了。由于比较简单，直接上代码

#include<bits/stdc++.h>
using namespace std;
int dp[100];
int main()
{
	int t, i, j, n, k;
	int N = 56;
	dp[1] = 1, dp[2] = 2, dp[3] = 3, dp[4] = 4;
	for (i = 5; i <= N; i++)
	{
		dp[i] = dp[i - 3] + dp[i - 1];
	}
	while (cin >> n,n)
	{
		cout << dp[n] << endl;
	}
	return 0;
}

E - 多重背包

<<<题目链接>>>

多重背包板子题

核心思想在于当物品数量*容量大于背包容量时就可以视为完全背包了，否则按照01背包处理。

还可以对其进行二进制优化，优化原理是1 2 4 8 16 … 2^k,n对2^k取余这些数可以表示为任意数。

#include<bits/stdc++.h>
using namespace std;
int dp[100005];
int w[200], v[200], c[200];
void _01(int n, int m, int w, int v)
{
    int i;
    for (i = n; i >= v; i--)
    {
        dp[i] = max(dp[i], dp[i - v] + w);
    }
}
void complete(int n, int m, int w, int v)
{
    int i;
    for (i = v; i <= n; i++)
    {
        dp[i] = max(dp[i], dp[i - v] + w);
    }
}
void merge(int n, int m, int w[], int v[], int c[])
{
    int i, j;
    for (i = 1; i <= m; i++)
    {
        if (v[i] * c[i] > n)
            complete(n, m, w[i], v[i]);
        else
        {
            int k = 1;
            while (k < c[i])
            {
                _01(n, m, w[i] * k, v[i] * k);
                c[i] -= k;
                k <<= 1;
            }
            _01(n, m, w[i] * c[i], v[i] * c[i]);
        }
    }
}
int main()
{
    int n, m, i, j, t;
    scanf("%d", &t);
    while (t--)
    {
        memset(dp, 0, sizeof(dp));
        scanf("%d%d", &n, &m);
        for (i = 1; i <= m; i++)
        {
            scanf("%d%d%d", &v[i], &w[i], &c[i]);
        }
        merge(n, m, w, v, c);
        int maxx = 0;
        for (i = 0; i <= n; i++)
        {
            maxx = max(dp[i], maxx);
        }
        printf("%d\n", maxx);
    }
    return 0;
}

F - 区间dp+四边形优化

<<<题目链接>>>

算是周赛的压轴题吧，但是也不算是，毕竟这道题是寒假训练的原题。简单区间dp会T，因为O(n³)复杂度是肯定过不了的，需要用到四边形优化。我为这道题以及四边形优化的原理单独写了一个博客
链接：
https://blog.youkuaiyun.com/weixin_45235164/article/details/114692273

四边形优化

首先我们先要了解满足四边形不等式所需要的条件。

当 $a1<a2\leqslant b1<b2$

且有 $m[a1,b1]+m[a2,b2]\leqslant m[a1,b2]+m[a2,b1]$ 时，满足四边形不等式
很显然，对于区间动态规划问题，上述不等式通常是成立的，因为a1~ b2已经包含了整个区间，再加上a2~b1，肯定是要比a1 ~ a2加b1 ~ b2大的
设 $s [i, j]$ 为 $m [i, j]$ 中取得最小值的k值，也就是 $m [i, j] = m [i, k] + m [k, j]$ 中的k
则有 $s[i,j-1]\leqslant s[i,j]\leqslant s[i+1][j]$
这个式子很容易证明，可以自己在草稿纸上尝试一下。
有了这个式子，那么k的取值也就是缩小到了 $s [i, j - 1] 到 s [i + 1, j]$ 之间了，从而降低了时间复杂度。

接下来上一道需要使用四边形优化的区间dp题。
题目链接 < 点我 >

石子归并问题

N堆石子摆成一个环。现要将石子有次序地合并成一堆。规定每次只能选相邻的2堆石子合并成新的一堆，并将新的一堆石子数记为该次合并的代价。计算将N堆石子合并成一堆的最小代价。

例如： 1 2 3 4，有不少合并方法 1 2 3 4 => 3 3 4(3) => 6 4(9) => 10(19) 1 2 3 4 =>
1 5 4(5) => 1 9(14) => 10(24) 1 2 3 4 => 1 2 7(7) => 3 7(10) => 10(20)

括号里面为总代价可以看出，第一种方法的代价最低，现在给出n堆石子的数量，计算最小合并代价。

这里要注意的是，环形石头的表示方法可以创建两条线性的石头序列，通过移动即可表示出环形。

#include<bits/stdc++.h>
#define bug(a) (cout<<'*'<<a<<endl)
#define bugg(a,b) (cout<<'*'<<a<<' '<<b<<endl)
#define buggg(a,b,c) (cout<<'*'<<a<<' '<<b<<' '<<c<<endl)
#define pn (cout<<endl)
typedef long long ll;
using namespace std;
int ar[5000];   
int sum[5000];  //前缀和，用来求区间和
int dp[2002][2002];
int f[2002][2002]; //k取值范围的数组
int main()
{
	int n, i, j, dis;
	memset(dp, 0x3f, sizeof(dp));
	scanf("%d", &n);
	for (i = 1; i <= n; i++)
	{
		scanf("%d", &ar[i]);
		ar[i + n] = ar[i];
		sum[i] = sum[i - 1] + ar[i];
		dp[i][i] = 0;
		dp[i + n][i + n] = 0;
		f[i][i] = i;//自己到自己的k值当然为本身
	}
	for (i = n + 1; i <= 2 * n; i++)
		sum[i] = sum[i - 1] + ar[i], f[i][i] = i;
	for (int k = 1; k < n; k++)
	{
		for (int i = 1; i + k <= 2 * n; i++)
		{
			int j = i + k;
			for (int p = f[i][j - 1]; p <= f[i + 1][j]; p++)//四边形优化
			{
				if (dp[i][j] > dp[i][p] + dp[p + 1][j] + sum[j] - sum[i - 1])
				{
					dp[i][j] = dp[i][p] + dp[p + 1][j] + sum[j] - sum[i - 1];
					f[i][j] = p;//记得更新！！！
				}
			}
		}
	}
	int ans = 0x3f3f3f3f;
	for (i = 1; i <= n; i++)
		ans = min(dp[i][i + n - 1], ans);
	printf("%d\n", ans);
	return 0;
}