01 knapsack about from two-dimensional optimization to one-dimensional optimization

#include<bits/stdc++.h>
using namespace std;
const int N = 1e3 + 10;
int wi[N], vi[N];
int n, v;
/*int dp[N][N];
int main() {
	cin >> n >> v;
	for (int i = 1; i <= n; i++) {
		cin >> vi[i] >> wi[i];
	}
	for (int i = 1; i <= n; i++) {
		for (int j = 0; j <= v; j++) {
			dp[i][j]=dp[i-1][j];
			if(j>=vi[i])
			{
				dp[i][j]=max(dp[i-1][j-vi[i]]+wi[i],dp[i][j]);
			}
		}
	}
	cout<<dp[n][v];
	return 0;
}*/
/*
	 From two-dimensional optimization to one-dimensional optimization 
	 After deleting all equivalents 
	for (int i = 1; i <= n; i++) {
			for (int j = vi[i]; j <= v; j++) {
				dp[j]=max(dp[j-vi[i]]+wi[i],dp[j]);
				// In this case , It is equivalent to 
				//dp[i][j]=max(dp[i][j],dp[i][j-vi[i])
				// Not equivalent to 
				//dp[i][j]=max(dp[i][j],dp[i-1][j-vi[i])
				/// because j-vi[i] Is strictly less than j Of , When we j From small to large 
				   When , Current i Layer of [j-vi[i]] In fact, it has been calculated , in other words 
				   The first i-1 Layer of [j-vi[i]] Has been i Layer of  [j-vi[i]] Updated .
				///
				 And how to solve this problem , Just count the number i Layer of [j-vi[i]] When 
				dp[j-vi[i]] It's still the first time to save i-1 Layer data is enough , We will j Enumeration from large to small 
				 When enumeration to j When , Because it is strictly greater than j-vi[i]], And we enumerate from large to small 
				 therefore dp[j-vi[i]] The saved data has not been updated to , That is, the first i-1 Layer data .

			}
		}
*/

int dp[N];
int main() {
	cin >> n >> v;
	for (int i = 1; i <= n; i++) {
		cin >> vi[i] >> wi[i];
	}
	for (int i = 1; i <= n; i++) {
		for (int j = v; j >= vi[i]; j--) {
			dp[j] = max(dp[j - vi[i]] + wi[i], dp[j]);
		}
	}
	cout << dp[v];
	return 0;
}