[Codeforces Round #635 (div2)]1348E - Phoenix and Berries[dp]

1348E - Phoenix and Berries[$dp$]

time limit per test	memory limit per test	input	output
2 seconds	256 megabytes	standard input	standard output

Description:

Phoenix is picking berries in his backyard. There are $n$ shrubs, and each shrub has $a_i$ red berries and bi blue berries.

Each basket can contain $k$ berries. But, Phoenix has decided that each basket may only contain berries from the same shrub or berries of the same color (red or blue). In other words, all berries in a basket must be from the same shrub or/and have the same color.

For example, if there are two shrubs with $5$ red and $2$ blue berries in the first shrub and $2$ red and $1$ blue berries in the second shrub then Phoenix can fill $2$ baskets of capacity $4$ completely:

  the first basket will contain $3$ red and $1$ blue berries from the first shrub;
  the second basket will contain the $2$ remaining red berries from the first shrub and $2$ red berries from the second shrub.

Help Phoenix determine the maximum number of baskets he can fill completely!

Input

The first line contains two integers $n$ and $k(1\le n,k\le 500)$ — the number of shrubs and the basket capacity, respectively.
The $i$-th of the next $n$ lines contain two integers $a_i$ and $b_i$ $(0\le a_i,b_i\le 10^9)$ — the number of red and blue berries in the $i$-th shrub, respectively.

Output

Output one integer — the maximum number of baskets that Phoenix can fill completely.

One Example input

2 4
5 2
2 1

One Example output

2

Two Example input

1 5
2 3

Two Example output

1

Three Example input

2 5
2 1
1 3

Three Example output

0

Four Example input

1 2
1000000000 1

Four Example output

1

Hit

The first example is described above.

In the second example, Phoenix can fill one basket fully using all the berries from the first (and only) shrub.

In the third example, Phoenix cannot fill any basket completely because there are less than $5$ berries in each shrub, less than $5$ total red berries, and less than $5$ total blue berries.

In the fourth example, Phoenix can put all the red berries into baskets, leaving an extra blue berry behind.

分析：
参考博客 [动态规划] Codeforces 1348E Phoenix and Berries

题意：
每棵灌木有红色浆果($a_i$)和蓝色浆果($b_i$)，每个篮子可以放 $k$ 个浆果，
每个篮子有以下两种放法：
$a.$ 每个篮子只能放来自同一灌木的浆果
$b.$ 每个篮子只能放同一种颜色的浆果
问最多可以完全装满的最大的篮子数

做法：
可以考虑到 $dp[i][red][blue]$，
即到第 $i$ 个篮子为止，红色浆果剩余 $red$，蓝色浆果剩余 $blue$，最大满篮数
由于剩余的个数应该 $0\le red,blue<k$
这样的话时间复杂度 $O(500\ast 500\ast 500)$，卡一卡过得去
但是空间复杂度 $O(500\ast 500\ast 500)$ 显然是不可以的
可以考虑将蓝色浆果的略去

令 $dp[i][j]$ 为到第 $i$ 个灌木为止，剩余 $j$ 个红浆果，最大满篮数
假设现在到 $i-1$ 为止剩余红浆果为 $j$ 个，$tsum={\sum }_{1\le q\le i-1}(a_q+b_q)$
到 $i-1$ 为止剩余的 $red+blue=sum=tsum-k\ast dp[i-1][j]$
到 $i$ 为止，红浆果为 $red=j+a[i]$, 蓝浆果为 $blue=sum-red+b[i]=sum-j+b[i]$

1. 先计算直接将 相同颜色的浆果 放进篮子中后的满篮子数
   $sr=(red+a[i])\%k=(j+a[i]\%k)$，即剩余的红浆果
   $dp[i][sr]=dp[i-1][j]+red/k+blue/k$
2. 暴力遍历该灌木的 $t$ 个红浆果 和 $k-t$ 个蓝浆果放一篮
   $l=max(0,k-b[i]),r=min(k,a[i])$，分别为 $t$ 的最小和最大取值
   则到目前为止
   $sr=red-t,sb=blue-(k-t)$，分别为放完混的这一篮后剩余的红、蓝浆果
   $dp[i][sr\%k]=max(dp[i][sr\%k],dp[i-1][j]+1+sr/k+sb/k)$

温馨提示：
这里取余最好是定义一个值存着用
不然公式里面取余会 $T$，(是的我就是为了好看T了
当然其实可以再进行压缩一下，利用循环数组
可以发现 $dp[i]$ 只与 $dp[i-1]$ 有关，因此其实只要 $dp[2][maxn]$ 也就可以了
因此 $dp[2][maxn][maxn]$ 貌似也没什么问题 ？

Code:

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define max(a,b) ((a)>(b)?(a):(b))
const int maxn = 500 + 5;
const int maxm = 3e6 + 5;
 
int re() {
    int x = 0, f = 1; char c = getchar();
    while(c<'0'||c>'9'){if(c=='-')f=-f; c=getchar();}
    while(c>='0' && c<='9'){x=(x<<3)+(x<<1)+c-'0'; c=getchar();}
    return x * f;
}
 
ll dp[maxn][maxn]; // 到前 i 颗，红色剩 j
int a[maxn];
int b[maxn];
 
int main() {
    int n, k;
    scanf("%d%d", &n, &k);
    memset(dp, -1, sizeof(dp));
    for(int i = 1; i <= n; ++i)
        a[i] = re(), b[i] = re();
    
    int l, r;
    ll tsum = 0, sum, sr, sb;
    dp[0][0] = 0;
    for(int i = 1; i <= n; ++i) {
        for(int j = 0; j < k; ++j) {
            if(dp[i - 1][j] < 0)    continue;
            sum = tsum - k * 1ll * dp[i - 1][j];
            sr = (j + a[i])%k, sb = sum - j + b[i];
            dp[i][sr] = dp[i - 1][j] + (j+a[i])/k + sb/k;
            l = max(0, k - b[i]), r = min(k, a[i]);
            for(int t = l; t <= r; ++t) { // 第i个取几个红色混放
                sr = (j - t + a[i])%k, sb = sum - j + b[i] - (k - t); // 剩余红色, 蓝色
                dp[i][sr] = max(dp[i][sr], dp[i-1][j] + 1 + (j - t + a[i])/k + sb/k);
            }
        }
        tsum += (a[i] + b[i]) * 1ll;
    }
    ll ans = 0;
    for(int i = 0; i < k; ++i)
        ans = max(ans, dp[n][i]);
    printf("%lld\n", ans);
    return 0;
}