acwing1047. 糖果

Posted 2023-04-09 踏过山河，踏过海

acwing1047. 糖果

acwing1047. 糖果

• 提问1:为什么最终的答案即为 $f[N][0]$?
• 提问2:$f[i][j]=f[i-1][j]$代表是什么意思

/*
输入样例：
5 7
1
2
3
4
5
输出样例：
14
样例解释
Dzx的选择是2+3+4+5=14，这样糖果总数是7的倍数，并且是总数最多的选择。
*/
//我们可以使用一个二维数组 f[i][j] 表示前 i 件物品中选取总重量不超过 j 的物品的最大价值

#include <iostream>
#include <cstring>
using namespace std;

const int N = 110, INF = 0x3f3f3f3f;

int f[N][N];

int main() 
    int n, k;
    cin >> n >> k;

    memset(f, -INF, sizeof f);
    f[0][0] = 0;

    for (int i = 1; i <= n; i++) 
        int w,v;
        cin >> w;
        v = w%k;
        for (int j = 0; j < k; j++) 
            //我们可以使用一个二维数组 f[i][j] 表示前 i 件产品中选取总价值为 j 且是 K 的倍数的物品的最大价值。
            //则有如下的状态转移方程：
            f[i][j] = max(f[i-1][j], f[i-1][(j -v + k)%k] + w);//j -v + k防止下标越界
            //其中 v 表示第 i 件产品中包含的糖果数量对 K 取模后的值，w 表示第 i 件产品的价值。
        
    
    
    最终的答案即为 f[N][0]。
    printf("%d\\n",f[n][0]);

    return 0;

提问1:为什么最终的答案即为 $f[N][0]$?

简答:

其实就是从$N$件物品中挑了几件,刚好挑的这几件物品总和%$k==0$

详答:

在本题中，我们需要选取若干件物品，使得选取的物品的总价值能够被 $K$ 整除。

因此，我们可以定义一个二维数组 $f[i][j]$，表示前 $i$ 件产品中选取总价值为 $j$ 且是 $K$ 的倍数的物品的最大价值。其中，$i$ 表示前 $i$ 件产品，j 表示选取的物品的总价值。
最终的答案即为 $f[N][0]$，表示前 $N$ 件产品中选取总价值为 0 且是 $K$ 的倍数的物品的最大价值。

这是因为题目要求选取的物品的总价值必须能够被 $K$ 整除，而 0 是 K 的倍数，因此最终的答案必须是 $f[N][0]$。

提问2:$f[i][j]=f[i-1][j]$代表是什么意思

在本题中，状态转移方程 $$f[i][j]=max(f[i-1][j],f[i-1][(j-v+k)\%k]+w)$$ 中，$f[i-1][j]$ 表示前 $i-1$ 件产品中选取总价值为 $j$ 且是 $K$ 的倍数的物品的最大价值。怎么保证是k的倍数,那就要对j取余,对j取余不方便,我们就对w取余;又因为怕出现负下标,还要再加上一个k

因为$v=w\%k$,所以,完整的状态转移方程应该是 $$f[i][j]=max(f[i-1][j],f[i-1][(j-w\%k+k)\%k]+w)$$

具体来说，我们使用二维数组 $f[i][j]$ 来表示前 $i$ 件产品中选取总价值为 $j$且是 $K$ 的倍数的物品的最大价值。因此，当我们要求前 i 件产品中选取总价值为 j 且是 K 的倍数的物品的最大价值时，可以分为两种情况：

1. 不选取第 i 件产品，则前 i 件产品中选取总价值为 j 且是 K 的倍数的物品的最大价值为 $f[i-1][j]$。
2. 选取第 i 件产品，则前 i 件产品中选取总价值为 j 且是 K 的倍数的物品的最大价值为 $f[i-1][(j-v+k)\%k]+w$。

因此，状态转移方程 $$f[i][j]=max(f[i-1][j],f[i-1][(j-v+k)\%k]+w)$$ 就是将这两种情况的最大值作为前 i 件产品中选取总价值为 j 且是 K 的倍数的物品的最大价值。

AcWing 4247. 糖果（差分约束最短路）

题目连接

https://www.acwing.com/problem/content/4250/

http://poj.org/problem?id=3159

思路

假设第i个同学得到的糖果数量为$a[i]$，然后第j个同学得到的糖果数位$a[j]$现在要求第j个同学的糖果数不超过$a[i]+k$个，也就是$a[j]-a[i]<=k$，那么我们要求的就是$a[n]-a[1]$的最大值

我们将上述不等式变形：$a[j]<=a[i]+k$，我们发现这个等式不就是最短路的松弛条件吗，所以我们直接将$a$、$b$连成一条有向边，边权为$c$，然后跑一个起点为1的最短路即可，最后输出$dis[n]$的值，这个题也是一个经典的差分约束题目，关于差分约束简单提一下，感兴趣可以去百度一下，差分约束就是给出一些形如x-y<=b不等式的约束，问你是否满足有解的问题

代码

链式前向星优化

#include<iostream>
#include<cstring>
#include<algorithm>
#include<cstdio>
#include<queue>
using namespace std;
#define PII pair<int,int>
#define INF 0x3f3f3f3f
const int N = 150000 + 10;

struct Node
	int v,w,next;
E[N];
int head[N],dis[N],cnt,n,m,vis[N];

void add(int u,int v,int w)
	E[cnt].v = v;
	E[cnt].w = w;
	E[cnt].next = head[u];
	head[u] = cnt++;


void DJ(int s)
	priority_queue<PII,vector<PII>,greater<PII> > que;
	que.push(0,s);
	dis[s] = 0;
	while(!que.empty())
		int t = que.top().second;
		int w = que.top().first;
		que.pop();
		if(dis[t] < w) continue;
		for(int i = head[t];~i;i=E[i].next)
			int j = E[i].v;
			if(dis[j] > dis[t] + E[i].w)
				dis[j] = dis[t] + E[i].w;
				que.push(dis[j],j);
			
		
	



int main()

	scanf("%d%d",&n,&m);
	memset(dis,0x3f,sizeof dis);
	memset(head,-1,sizeof head);
	int u,v,w;
	for(int i = 1;i <= m; ++i) 
		scanf("%d%d%d",&u,&v,&w);
		add(u,v,w);
	
	DJ(1);
	printf("%d\\n",dis[n]);
	
	return 0;

vector容器存储

#include<bits/stdc++.h>
using namespace std;
//----------------自定义部分----------------
#define ll long long
#define mod 1000000007
#define endl "\\n"
#define PII pair<int,int>
#define INF 0x3f3f3f3f

int dx[4]=0,-1,0,1,dy[4]=-1,0,1,0;

ll ksm(ll a,ll b) 
	ll ans = 1;
	for(;b;b>>=1LL) 
		if(b & 1) ans = ans * a % mod;
		a = a * a % mod;
	
	return ans;


ll lowbit(ll x)return -x & x;

const int N = 2e6+10;
//----------------自定义部分----------------
int n,m,q;

vector<PII> E[N];
int dis[N];
bool vis[N];

void slove()
	memset(dis,INF,sizeof dis);
	dis[1] = 0;
	priority_queue<PII,vector<PII>,greater<PII> >que;
	que.push(0,1);
	while(!que.empty())
		PII t = que.top();
		que.pop();
		int p = t.second;
		if(vis[p]) continue;
		vis[p] = true;
		for(int i = 0,l = E[p].size(); i < l; ++i)
			int j = E[p][i].first,k = E[p][i].second;
			if(dis[j] > dis[p] + k)
				dis[j] = dis[p] + k;
				que.push(dis[j],j);
			
			
	
	if(dis[n] == INF)
		cout<<-1<<endl;
	else cout<<dis[n]<<endl;


int main()

	std::ios::sync_with_stdio(false);
	std::cin.tie(nullptr);
	std::cout.tie(nullptr);
	
	cin>>n>>m;
	
	int u,v,w;
	for(int i = 0;i < m; ++i) 
		cin>>u>>v>>w;
		E[u].push_back(v,w);
	
	slove();
	
	return 0;