text
stringlengths 49
983k
|
|---|
#include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
using ll = int64_t;
#define rep(i, j, n) for (int i = j; i < (int)n; ++i)
ll dp[3003][3003][4];
ll gs[3003][3003];
int main() {
int r, c, k, y, x, v;
cin >> r >> c >> k;
rep(i, 0, k) {
cin >> y >> x >> v;
--y, --x;
gs[y][x] = v;
}
rep(i, 0, r) rep(j, 0, c) rep(a, 0, 4) {
if (a + 1 < 4) {
dp[i][j + 1][a + 1] = max(dp[i][j + 1][a + 1], dp[i][j][a] + gs[i][j]);
dp[i + 1][j][0] = max(dp[i + 1][j][0], dp[i][j][a] + gs[i][j]);
}
dp[i][j + 1][a] = max(dp[i][j + 1][a], dp[i][j][a]);
dp[i + 1][j][0] = max(dp[i + 1][j][0], dp[i][j][a]);
}
ll ans = 0;
rep(a, 0, 4) {
ans = max(ans, dp[r][c - 1][a]);
ans = max(ans, dp[r - 1][c][a]);
}
cout << ans << '\n';
return 0;
}
|
#include <iostream>
using namespace std;
typedef long long Int;
Int H, W, K, h, w, v;
Int dp[5500][5500][4], fld[5500][5500];
int main() {
cin >> H >> W >> K;
for (int _ = 0; _ < K; _++) {
cin >> h >> w >> v;
fld[h - 1][w - 1] = v;
}
for (int i = 1; i <= H; i++) {
for (int j = 1; j <= W; j++) {
Int v = fld[i - 1][j - 1];
for (int k = 0; k < 4; k++) {
dp[i][j][0] = max(dp[i][j][0], dp[i - 1][j][k]);
if (0 < i) {
dp[i][j][1] = max(dp[i][j][1], dp[i - 1][j][k] + v);
}
dp[i][j][k] = max(dp[i][j][k], dp[i][j - 1][k]);
if (0 < k - 1) {
dp[i][j][k] = max(dp[i][j][k], dp[i][j - 1][k - 1] + v);
}
}
}
}
Int ans = 0;
for (int i = 0; i < 4; i++) {
ans = max(ans, dp[H][W][i]);
}
cout << ans << endl;
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define ll long long
#define P pair<int,int>
#define PI 3.141592653589793
const int INF = 1001001001;
const ll MX = 1e18;
const int mod = 1000000007;
template<class T> inline bool chmax(T& a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
int a[3005][3005];
ll dp[3005][3005][4];
int main() {
int R, C, n;
cin >> R >> C >> n;
rep(i, n) {
int r,c,v;
cin >> r >> c >> v;
r--; c--;
a[r][c] = v;
}
dp[0][0][0] = 0;
rep(i, R)rep(j, C) {
for (int K = 2; K >= 0; K--) {
chmax(dp[i][j][K+1], dp[i][j][K] + a[i][j]);
}
rep(k, 4) {
chmax(dp[i + 1][j][0], dp[i][j][k]);
chmax(dp[i][j+1][k], dp[i][j][k]);
}
}
ll ans = 0;
rep(k,4) {
ans = max(ans,dp[R-1][C-1][k]);
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
#define rep(i,n) for (int i=0; i<(n); ++i)
using namespace std;
typedef long long ll;
typedef pair<int,int> P;
int a[3010][3010];
ll dp[3010][3010][4];
int main(){
int R,C,K;
cin>>R>>C>>K;
rep(i,K){
int r,c,v; cin>>r>>c>>v;
a[r-1][c-1]=v;
}
for(int i=0; i<R; ++i){
for(int j=0; j<C; ++j){
for(int k=2; k>=0; --k){
dp[i][j][k+1]=max(dp[i][j][k+1],dp[i][j][k]+a[i][j]);
}
rep(k,4){
dp[i+1][j][0]=max(dp[i+1][j][0],dp[i][j][k]);
dp[i][j+1][k]=max(dp[i][j+1][k],dp[i][j][k]);
}
}
}
ll ans=0;
rep(i,4)ans=max(ans,dp[R-1][C-1][i]);
cout<<ans<<endl;
}
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
#define pb pushback
#define fr(i,n) for(int i=0;i<n;i++)
#define fro(i,j,n) for(int i=j;i<n;i++)
#define ifr(i,n) for(int i=n-1;i>=0;i--)
int main() {
int r,c,k,x,y,z;
cin >> r>> c>> k;
ll a[3*r+1][c];
int v[r][c];
fr(i,r){
fr(j,c){
v[i][j]=0;
}
}
fr(i,k){
cin >> x>> y >> z;
v[x-1][y-1]=z;
}
fr(i,3*r+1){
fr(j,c){
if(i==0)a[i][j]=0;
else if(j==0)a[i][j]=a[int((i-1)/3)*3][j]+v[(i-1)/3][0];
else if(i%3==1){
a[i][j]=max(a[i-1][j]+v[(i-1)/3][j],a[i][j-1]);
}
else{
a[i][j]=max(a[i-1][j-1]+v[(i-1)/3][j],max(a[i-1][j],a[i][j-1]));
}
}
}
cout <<a[3*r][c-1]<< endl;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
ll dp[3001][3001][3], a[3001][3001];
int main() {
ll r,c,items, x , y, v, maxi = 0;
cin >> r >> c >> items;
while(items--) {
cin >> x >> y >> v;
x--, y--;
dp[x][y][0] = a[x][y] = v;
}
for(int i=0;i<r;i++) for(int j=0;j<c;j++) {
for(int k=0;k<3;k++) {
if(j+1 < c) dp[i][j+1][k] = max(dp[i][j+1][k], dp[i][j][k]);
if(j+1 < c && k > 0) dp[i][j+1][k] = max(dp[i][j+1][k], dp[i][j][k-1] + a[i][j+1]);
}
if(i+1 < r) dp[i+1][j][0] = dp[i+1][j][1] = dp[i+1][j][2] = max({dp[i][j][0], dp[i][j][1], dp[i][j][2]}) + a[i+1][j];
}
for(int k=0;k<3;k++) maxi=max(maxi,dp[r-1][c-1][k]);
cout << maxi;
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
using ll=long long;
ll dp[3100][3100][5];
ll value[3100][3100];
int main(){
int r,c,k;
cin >> r >> c >> k;
memset(value,0,sizeof(value));
for(int i=0;i<k;++i){
ll R,C,V;
cin >> R >> C >> V;
value[R][C]=V;
}
for(int i=0;i<=r;++i){
for(int j=0;j<=c;++j){
for(int k=0;k<=3;++k){
if(i-1>=0){
dp[i][j][0]=max(dp[i][j][0],dp[i-1][j][k]);
dp[i][j][1]=max(dp[i][j][1],dp[i-1][j][k]+value[i][j]);
}
if(j-1>=0){
dp[i][j][k]=max(dp[i][j][k],dp[i][j-1][k]);
if(k-1>=0){
dp[i][j][k]=max(dp[i][j][k],dp[i][j-1][k-1]+value[i][j]);
}
}
}
}
}
ll ans=0;
for(int i=0;i<=3;++i)ans=max(ans,dp[r][c][i]);
cout << ans << endl;
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
typedef int64_t ll;
#define rep(i,n) for(int i=1;i<=(int)(n);i++)
ll R,C,K,r,c,v,g[3001][3001],a[3001][3001][4];
int main(){
cin>>R>>C>>K;
rep(i,K){cin>>r>>c>>v;g[r][c]=v;}
rep(i,R)rep(j,C)rep(k,3)a[i][j][k]=max(a[i-1][j][3]+g[i][j],max(a[i][j-1][k-1]+g[i][j],a[i][j-1][k]));
cout<<a[R][C][3]<<endl;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn=3003;
ll dp[maxn][maxn][4];
ll val[maxn][maxn];
int main()
{
int n,m,k,x,y;
ll v;
scanf("%d%d%d",&n,&m,&k);
for(int i=1;i<=k;i++)
{
scanf("%d%d%lld",&x,&y,&v);
val[x][y]=v;
}
for(int i=1;i<=n;i++)
{
for(int j=1;j<=m;j++)
{
for(int k=0;k<=3;k++)
{
dp[i][j][k]=max(dp[i][j][k],dp[i-1][j][0]);
dp[i][j][k]=max(dp[i][j][k],dp[i-1][j][1]);
dp[i][j][k]=max(dp[i][j][k],dp[i-1][j][2]);
dp[i][j][k]=max(dp[i][j][k],dp[i-1][j][3]);
dp[i][j][k]=max(dp[i][j][k],dp[i][j-1][k]);
}
if(val[i][j]) for(int k=3;k;k--) dp[i][j][k]=max(dp[i][j][k],dp[i][j][k-1]+val[i][j]);
}
}
ll ans=0;
for(int i=0;i<=3;i++)
{
ans=max(ans,dp[n][m][i]);
}
printf("%lld",ans);
}
|
#include <bits/stdc++.h>
using namespace std;
long long n,m,k;
long long dp[3010][3010][4];
long long a[3010][3010];
int main(){
cin>>n>>m>>k;
while(k--){
long long u,v,w;
cin>>u>>v>>w;
a[u][v]=w;
}
dp[1][1][1]=a[1][1];
for(long long i=1;i<=n;i++){
for(long long j=1;j<=m;j++){
for(long long k=0;k<=2;k++){
dp[i+1][j][0]=max(dp[i+1][j][0],dp[i][j][k]);
dp[i+1][j][1]=max(dp[i+1][j][1],dp[i][j][k]+a[i+1][j]);
dp[i][j+1][k]=max(dp[i][j+1][k],dp[i][j][k]);
dp[i][j+1][k+1]=max(dp[i][j+1][k+1],dp[i][j][k]+a[i][j+1]);
}
dp[i+1][j][0]=max(dp[i+1][j][0],dp[i][j][3]);
dp[i+1][j][1]=max(dp[i+1][j][1],dp[i][j][3]+a[i+1][j]);
dp[i][j+1][3]=max(dp[i][j+1][3],dp[i][j][3]);
}
}
cout<<max(dp[n][m][0],max(dp[n][m][1],max(dp[n][m][2],dp[n][m][3])));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int dp[3001][3001][4];
long long int sc[3001][3001];
int main(){
int R,C,k;
cin >> R >> C >> k;
int r,c;
long long int v;
for(int i=0;i<k;i++){
cin >> r >> c >> v;
r --; c--;
sc[r][c]=v;
}
for(int i=0;i<R;i++){
for(int j=0;j<C;j++){
for(int m=0;m<4;m++){
if(sc[i][j]>0 && m<3){
dp[i][j+1][m+1]=max(dp[i][j][m]+sc[i][j],dp[i][j+1][m+1]);
dp[i+1][j][0]=max(dp[i][j][m]+sc[i][j],dp[i+1][j][0]);
}
dp[i][j+1][m]=max(dp[i][j][m],dp[i][j+1][m]);
dp[i+1][j][0]=max(dp[i][j][m],dp[i+1][j][0]);
}
}
}
cout << dp[R][C-1][0];
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3001;
int g[N][N];
int64_t dp[N][N][4];
int R, C, K;
int64_t go(int x, int y, int cnt) {
if (x == R || y == C) return 0;
if (dp[x][y][cnt] != -1) return dp[x][y][cnt];
if (cnt < 3) {
return dp[x][y][cnt] = max({go(x, y + 1, cnt + 1) + g[x][y], go(x + 1, y, 0) + g[x][y], go(x, y + 1, cnt), go(x + 1, y, 0)});
} else {
return dp[x][y][cnt] = max(go(x, y + 1, cnt), go(x + 1, y, 0));
}
}
int32_t main()
{
ios::sync_with_stdio(false), cin.tie(nullptr);
cin >> R >> C >> K;
for (int i = 0; i < K; i++) {
int x, y, v; cin >> x >> y >> v;
x--, y--;
g[x][y] = v;
}
memset(dp, -1, sizeof dp);
cout << go(0, 0, 0);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long A[3010][3010];
long long dp[3010][3010][4];
int main(){
ios::sync_with_stdio(0);
cin.tie(0); cout.tie(0);
int R, C, K; cin >> R >> C >> K;
for(int i = 0; i < K; i++){
int r, c; long long v; cin >> r >> c >> v;
r--; c--; A[r][c] = v;
}
if(A[0][0]) dp[0][0][1] = A[0][0];
for(int i = 0; i < R; i++){
for(int j = 0; j < C; j++){
for(int k = 0; k <= 3; k++){
dp[i][j+1][k] = max(dp[i][j+1][k], dp[i][j][k]);
if(A[i][j+1] && (k < 3)) dp[i][j+1][k+1] = max(dp[i][j+1][k+1], dp[i][j][k] + A[i][j+1]);
dp[i+1][j][0] = max(dp[i+1][j][0], dp[i][j][k]);
if(A[i+1][j]) dp[i+1][j][1] = max(dp[i+1][j][1], dp[i][j][k] + A[i+1][j]);
}
}
}
long long ans = 0;
for(int i = 0; i <= 3; i++) ans = max(ans, dp[R-1][C-1][i]);
cout << ans << "\n";
}
|
#include <bits/stdc++.h>
#define int long long
using namespace std;
int n, m, k;
const int N = 3000;
int cache[N][N][4];
int a[N][N];
int dp(int i, int j, int last)
{
if (i == n || j == m)
return 0;
int &ans = cache[i][j][last];
if (ans != -1)
return ans;
if (last == 3)
{
ans = dp(i + 1, j, 0);
}
else
ans = max({ans, a[i][j] + dp(i + 1, j, 0), dp(i, j + 1, last), a[i][j] + dp(i, j + 1, last + 1)});
return ans;
}
int32_t main()
{
cin >> n >> m >> k;
for (int i = 0; i < k; i++)
{
int x, y, c;
cin >> x >> y >> c;
x--;
y--;
a[x][y] = c;
}
memset(cache, -1, sizeof(cache));
cout << dp(0, 0, 0);
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
#define ll long long
ll g[4001][4001];
int r,c,k;
ll dp[4001][4001][4];
ll rec(ll i, ll j, ll taken)
{
if(i>=r)return 0;
if(j>=c)return 0;
if(dp[i][j][taken]!=-1)return dp[i][j][taken];
ll ans=0;
ans=rec(i+1,j,0);
if(taken<3){
ans=max(ans,rec(i+1,j,0)+g[i][j]);
}
ans=max(ans,rec(i,j+1,taken));
if(taken<3){
ans=max(ans,rec(i,j+1,taken+1)+g[i][j]);
}
return dp[i][j][taken]=ans;
}
int main()
{
cin>>r>>c>>k;
for(int i=0;i<r;i++)
{
for(int j=0;j<c;j++)
{
g[i][j]=0;
}
}
for(int i=0;i<k;i++)
{
int a,b,v; cin>>a>>b>>v;
a--; b--;
g[a][b]=v;
}
memset(dp,-1,sizeof(dp));
cout<<rec(0,0,0);
}
|
#include <bits/stdc++.h>
#define rep(i,n) for (int i=0; i<(n); ++i)
using namespace std;
typedef long long ll;
typedef pair<int,int> P;
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }
int a[3010][3010];
ll dp[3010][3010][4];
int main(){
int R,C,K;
cin>>R>>C>>K;
rep(i,K){
int r,c,v; cin>>r>>c>>v;
a[r-1][c-1]=v;
}
for(int i=0; i<R; ++i){
for(int j=0; j<C; ++j){
for(int k=2; k>=0; --k){
chmax(dp[i][j][k+1],dp[i][j][k]+a[i][j]);
}
rep(k,4){
chmax(dp[i+1][j][0],dp[i][j][k]);
chmax(dp[i][j+1][k],dp[i][j][k]);
}
}
}
ll ans=0;
rep(i,4)chmax(ans,dp[R-1][C-1][i]);
cout<<ans<<endl;
}
|
#include<bits/stdc++.h>
#define PI 3.141592653589793238462
using namespace std;
typedef long long ll;
typedef long double db;
ll d[3005][3005][5],a[3005][3005];
int main(){
ll r,c,n;cin>>r>>c>>n;
for(ll i=1;i<=n;i++){
ll x,y,v;cin>>x>>y>>v;
a[x][y]=v;
}
for(int i=1;i<=r;i++){
for(int j=1;j<=c;j++){
for(int k=0;k<=3;k++){
d[i][j][k]=max(d[i][j][k],d[i][j-1][k]);
d[i][j][0]=max(d[i][j][0],d[i-1][j][k]);
if(a[i][j]>0){
if(k>0) d[i][j][k]=max(d[i][j][k],d[i][j-1][k-1]+a[i][j]);
d[i][j][1]=max(d[i][j][1],d[i-1][j][k]+a[i][j]);
}
}
}
}
ll ans=0;
for(int i=0;i<=3;i++){
ans=max(ans,d[r][c][i]);
}
cout<<ans<<endl;
}
|
#include<bits/stdc++.h>
using namespace std;
long long int L[3003][3003][4];
int G[3003][3003];
int H,W,K;
signed main(){
cin>>H>>W>>K;
int h,w,v;
for(int i=1;i<=K;i++){
cin>>h>>w>>v;
G[h][w]=v;
}
for(int h=1;h<H+1;h++){
for(int w=1;w<W+1;w++){
long long int X=0;
for(int k=0;k<4;k++){
X=max(X,L[h-1][w][k]);
}
for(int k=1;k<4;k++){
L[h][w][k]=max(max(L[h][w-1][k],L[h][w-1][k-1]+G[h][w]),X+G[h][w]);
}
}
}
long long int ans=0;
for(int i=0;i<=3;i++){
ans=max(ans,L[H][W][i]);
}
cout<<ans<<endl;
return 0;
}
|
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
#define chmax(x, y) x = max(x, y)
using namespace std;
using ll = long long;
int a[3005][3005];
ll dp[3005][3005][4];
int main() {
int R, C, n;
cin >> R >> C >> n;
rep(i, n) {
int r , c, v;
cin >> r >> c >> v;
a[r - 1][c - 1] = v;
}
rep(i, R) rep(j, C) {
for (int k = 2; k >= 0; k--) {
chmax(dp[i][j][k + 1], dp[i][j][k] + a[i][j]);
}
rep(k, 4) {
chmax(dp[i + 1][j][0], dp[i][j][k]);
chmax(dp[i][j + 1][k], dp[i][j][k]);
}
}
ll ans = 0;
rep(k, 4) chmax(ans, dp[R - 1][C - 1][k]);
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
#define chmax(x, y) x = max(x, y)
using namespace std;
typedef long long ll;
ll a[3005][3005], dp[3005][3005][4];
int main() {
ll R, C, n, ans = 0, r, c, v;
cin >> R >> C >> n;
rep(i, n) cin >> r >> c >> v, a[r][c] = v;
rep(i, R + 1) rep(j, C + 1) rep(k, 3 + 1) {
if (i - 1 >= 0) {
chmax(dp[i][j][0], dp[i - 1][j][k]);
chmax(dp[i][j][1], dp[i - 1][j][k] + a[i][j]);
}
if (j - 1 >= 0) {
chmax(dp[i][j][k], dp[i][j - 1][k]);
if (k - 1 >= 0) chmax(dp[i][j][k], dp[i][j - 1][k - 1] + a[i][j]);
}
}
rep(k, 4) chmax(ans, dp[R][C][k]);
cout << ans << endl;
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define endl '\n'
#define FASTINOUT ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
const int N=3009;
ll a[N][N];
ll dp[N][N][5];
int r,c,k,l,m,v;
ll f(int i,int j,int cnt)
{
if (i>r||j>c)
return 0;
if (dp[i][j][cnt]!=-1)
return dp[i][j][cnt];
ll mx=0;
if (cnt<3)
{
mx=max(mx,a[i][j]+f(i,j+1,cnt+1));
mx=max(mx,a[i][j]+f(i+1,j,0));
}
mx=max(mx,f(i,j+1,cnt));
mx=max(mx,f(i+1,j,0));
return dp[i][j][cnt]=mx;
}
int main()
{
FASTINOUT;
cin>>r>>c>>k;
for (int i=1; i<=k; i++)
{
cin>>l>>m>>v;
a[l][m]=v;
}
memset(dp,-1,sizeof dp);
cout<<f(1,1,0);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std ;
const int MAX = 3000 + 10 ;
int arr[MAX][MAX] ;
int n , m , k ;
long long dp[MAX][MAX][4] ;
long long solve(int i , int j , int cnt)
{
if(i == n || j == m)
return 0 ;
long long &ret = dp[i][j][cnt] ;
if(ret != -1)
return ret ;
ret = 0 ;
ret = max(ret , solve(i+1 , j , 0)) ;
ret = max(ret , solve(i , j+1 , cnt)) ;
if(cnt != 3)
{
ret = max(ret , solve(i+1 , j , 0) + arr[i][j]) ;
ret = max(ret , solve(i , j+1 , cnt+1) + arr[i][j]) ;
}
return ret ;
}
int main()
{
memset(dp , -1 , sizeof(dp)) ;
ios_base::sync_with_stdio(0) ;
cin.tie(0) ;
cin>>n>>m>>k ;
while(k--)
{
int i , j ;
cin>>i>>j ;
i-- , j-- ;
cin>>arr[i][j] ;
}
return cout<<solve(0 , 0 , 0)<<"\n" , 0 ;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int r, c, k;
cin >> r >> c >> k;
vector<vector<vector<long long>>> dp(r + 1, vector<vector<long long>>(c + 1, vector<long long>(4)));
vector<vector<long long>> grid(r, vector<long long>(c));
for (int i = 0; i < k; i++) {
int a, b, v;
cin >> a >> b >> v;
grid[a - 1][b - 1] = v;
}
for (int i = 0; i < r; i++) {
for (int j = 0; j < c; j++) {
vector<long long> dp_before = dp[i][j];
for (int k = 0; k <= 3; k++) {
dp[i + 1][j][0] = max(dp[i + 1][j][0], dp[i][j][k]);
dp[i][j + 1][k] = max(dp[i][j + 1][k], dp[i][j][k]);
if (k < 3) {
dp[i][j][k + 1] = max(dp[i][j][k + 1], dp_before[k] + grid[i][j]);
}
}
}
}
cout << *max_element(dp[r - 1][c - 1].begin(), dp[r - 1][c - 1].end());
}
|
#include <bits/stdc++.h>
#define rep(i,n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
using vi=vector<int>;
using P = pair<int,int>;
using Graph = vector<vector<int>>;
#define chmax(x,y) x = max(x,y)
int a[3005][3005];
ll dp[3005][3005][4];
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
int R,C,n;
cin >> R >> C >> n;
rep(i,n){
int r,c,v;
cin >> r >> c >> v;
a[r-1][c-1]=v;
}
rep(i,R)rep(j,C){
for(int k=2;k>=0;--k){
chmax(dp[i][j][k+1],dp[i][j][k]+a[i][j]);
}
rep(k,4){
chmax(dp[i+1][j][0],dp[i][j][k]);
chmax(dp[i][j+1][k],dp[i][j][k]);
}
}
ll ans=0;
rep(k,4) chmax(ans,dp[R-1][C-1][k]);
cout << ans << "\n";
return 0;
}
|
#include <bits/stdc++.h>
#define rep(i,n) for (int i = 0; i < (n); ++i)
#define chmax(x,y) x = max(x,y)
using namespace std;
using ll = long long;
using P = pair<int,int>;
int a[3005][3005];
ll dp[3005][3005][4];
int main(){
int R,C,K;
cin >> R >> C >> K;
rep(i,K){
int r,c,v;
cin >> r >> c >> v;
a[r-1][c-1] = v;
}
rep(i,R) rep(j,C){
for(int k=2;k>=0;k--){
chmax(dp[i][j][k+1],dp[i][j][k]+a[i][j]);
}
rep(k,4){
chmax(dp[i+1][j][0],dp[i][j][k]);
chmax(dp[i][j+1][k],dp[i][j][k]);
}
}
ll ans=0;
rep(k,4) chmax(ans,dp[R-1][C-1][k]);
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn = 3000 + 10;
int r, c, k;
int v[maxn][maxn];
ll f[4][maxn][maxn];
int main()
{
scanf("%d%d%d", &r, &c, &k);
while(k--)
{
int x, y, val;
scanf("%d%d%d", &x, &y, &val);
v[x][y] = val;
}
for(int i = 1; i <= r; ++i)
for(int j = 1; j <= c; ++j)
for(int p = 3; ~p; --p)
{
if(i > 1) f[p][i][j] = max(f[p][i][j], f[3][i - 1][j]);
if(j > 1) f[p][i][j] = max(f[p][i][j], f[p][i][j - 1]);
if(p < 3) f[p + 1][i][j] = max(f[p + 1][i][j], f[p][i][j] + v[i][j]);
}
printf("%lld\n", f[3][r][c]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
ll dp[3001][3001][4], a[3001][3001];
int main() {
ll r,c,items, x , y, v, maxi = 0;
cin >> r >> c >> items;
while(items--) {
cin >> x >> y >> v;
a[x-1][y-1]=v;
}
for(int i=0;i<r;i++) for(int j=0;j<c;j++) {
for(int k=2;k>=0;k--) {
dp[i][j][k+1]=max(dp[i][j][k+1],dp[i][j][k]+a[i][j]);
}
for(int k=0;k<4;k++) {
if(j+1!=c) dp[i][j+1][k]=max(dp[i][j+1][k],dp[i][j][k]);
if(i+1!=r) dp[i+1][j][0]=max(dp[i+1][j][0],dp[i][j][k]);
}
}
for(int k=0;k<4;k++) maxi=max(maxi,dp[r-1][c-1][k]);
cout << maxi;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
ll dp[3001][3001][3], a[3001][3001];
int vis[3001][3001][3];
ll func(int r, int c, int cnt) {
if(r < 0 || c < 0 || cnt < 0) return 0;
if(vis[r][c][cnt]) return dp[r][c][cnt];
vis[r][c][cnt] = 1;
return dp[r][c][cnt] = max({func(r-1, c, 2) + a[r][c], func(r, c-1, cnt), func(r, c-1, cnt-1) + a[r][c]});
}
int main() {
ll r,c,items, x , y, v, maxi = 0;
cin >> r >> c >> items;
while(items--) {
cin >> x >> y >> v;
a[x-1][y-1]=v;
}
maxi = func(r-1, c-1, 2);
cout << maxi;
return 0;
}
|
#include<bits/stdc++.h>
#define debug printf("%d %s\n",__LINE__,__FUNCTION__)
typedef long long ll;
typedef std::pair<int,int> pii;
#define pb push_back
#define mk make_pair
#define fi first
#define se second
int _w;FILE* _f;
using namespace std;
const int N=3001;
int R,C,K,val[N][N];
ll f[N][N][4],ans;
int main(){
scanf("%d%d%d",&R,&C,&K);
for(int i=1,u,v,w;i<=K;i++){
scanf("%d%d%d",&u,&v,&w);
val[u][v]=w;
}
for(int i=1;i<=R;i++){
for(int j=1;j<=C;j++){
for(int k=1;k<=3;k++){
f[i][j][k]=max(max(f[i-1][j][3],f[i][j-1][k-1])+val[i][j],f[i][j-1][k]);
ans=max(ans,f[i][j][k]);
}
}
}
printf("%lld\n",ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define all(V) V.begin(),V.end()
const ll MOD = 1000000007;
ll M[3010][3010];
ll A[3010][3010][4];
int main() {
int R, C, K;
cin >> R >> C >> K;
int r, c, v;
for (int i = 0;i <= R;i++) {
for (int j = 0;j <= C;j++) {
M[i][j] = 0;
}
}
for (int i = 0;i < K;i++) {
cin >> r >> c >> v;
M[r][c] = v;
}
for (int i = 1;i <= R;i++) {
for (int j = 1;j <= C;j++) {
A[i][j][0] = max(A[i - 1][j][3], A[i][j - 1][0]);
A[i][j][1] = max(A[i][j][0] + M[i][j], A[i][j - 1][1]);
A[i][j][2] = max({ A[i][j][1],A[i][j - 1][1] + M[i][j], A[i][j - 1][2] });
A[i][j][3] = max({ A[i][j][2],A[i][j - 1][2] + M[i][j], A[i][j - 1][3] });
}
}
cout << A[R][C][3] << endl;
}
|
#include <iostream>
using namespace std;
typedef long long ll;
ll v[3005][3005];
ll dp[3005][3005][4];
int main()
{
int r, c, k;
cin >> r >> c >> k;
for(int i = 0; i < k; i++){
int a, b;
ll w;
cin >> a >> b >> w;
a--; b--;
v[a][b] = w;
}
for(int i = 1; i <= r; i++){
for(int j = 1; j <= c; j++){
dp[i][j][0] = max(dp[i][j - 1][0], dp[i - 1][j][3]);
dp[i][j][1] = max(dp[i][j][0] + v[i - 1][j - 1], dp[i][j - 1][1]);
dp[i][j][2] = max(max(dp[i][j - 1][1] + v[i - 1][j - 1], dp[i][j - 1][2]), dp[i][j][1]);
dp[i][j][3] = max(max(dp[i][j - 1][2] + v[i - 1][j - 1], dp[i][j - 1][3]), dp[i][j][2]);
}
}
cout << dp[r][c][3] << endl;
}
|
#include <bits/stdc++.h>
#define rep(i,n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
using P = pair<int,int>;
#define chmax(x,y) x = max(x,y);
const int di[] = {-1, 0, 1, 0};
const int dj[] = {0, -1, 0, 1};
const int INF = 1001001001;
int a[3005][3005];
ll dp[3005][3005][4];
int main() {
int R, C, K;
cin >> R >> C >> K;
rep(i,K) {
int r, c, v;
cin >> r >> c >> v;
a[r-1][c-1] = v;
}
rep(i,R)rep(j,C) {
for (int k = 2; k >= 0; k--) {
chmax(dp[i][j][k+1], dp[i][j][k] + a[i][j]);
}
rep(k,4) {
chmax(dp[i][j+1][k], dp[i][j][k]);
chmax(dp[i+1][j][0], dp[i][j][k]);
}
}
ll ans = 0;
rep(k,4) chmax(ans, dp[R-1][C-1][k]);
cout << ans << endl;
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
using LL = long long;
int main() {
int R, C, K;
cin >> R >> C >> K;
vector<vector<LL>> V(R+2, vector<LL>(C+2));
for(auto i=0; i<K; ++i) {
int r, c, v;
cin >> r >> c >> v;
V[r][c] = v;
}
vector<vector<vector<LL>>> dp(R+3, vector<vector<LL>>(C+3, vector<LL>(5)));
dp[1][1][1] = V[1][1];
for(auto i=1; i<=R; ++i) for(auto j=1; j<=C; ++j) for(auto k=0; k<4; ++k) {
dp[i+1][j][0] = max(dp[i+1][j][0], dp[i][j][k]);
dp[i][j+1][k] = max(dp[i][j+1][k], dp[i][j][k]);
dp[i+1][j][1] = max(dp[i+1][j][1], dp[i][j][k] + V[i+1][j]);
dp[i][j+1][k+1] = max(dp[i][j+1][k+1], dp[i][j][k] + V[i][j+1]);
}
cout << max({dp[R][C][0], dp[R][C][1], dp[R][C][2], dp[R][C][3]}) << endl;
}
|
#include<bits/stdc++.h>
#define ll long long
using namespace std;
ll val[3003][3003], mem[3003][3003][5], n, m;
ll dp(int r, int c, int cnt)
{
if(r>n || c>m || cnt>3)return -100000000000000000;
if(r==n && c== m)return (cnt<3)*val[n][m];
if(mem[r][c][cnt]!=-1)return mem[r][c][cnt];
return mem[r][c][cnt]= max(max((cnt<3)*val[r][c]+dp(r+1, c, 0), dp(r, c+1, cnt)), val[r][c]+dp(r, c+1, cnt+1));
}
int main()
{
ll k;
scanf("%lld %lld %lld", &n, &m, &k);
while(k--)
{
int x, y, z;
scanf("%d %d %d", &x, &y, &z);
val[x][y]= z;
}
memset(mem, -1, sizeof mem);
printf("%lld\n", dp(1, 1, 0));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int n,m,v[3003][3003],K;
ll dp[3003][3003][4];
int main(){
cin>>n>>m>>K;
for(int i=1;i<=K;i++){
int r,c,V;cin>>r>>c>>V;
v[r][c]=V;
}
dp[1][1][0]=0;if(v[1][1]>0)dp[1][1][1]=v[1][1];
for(int i=1;i<=n;i++)for(int j=1;j<=m;j++)if(i>1||j>1){
if(j>1){
for(int k=0;k<4;k++)dp[i][j][k]=max(dp[i][j][k],dp[i][j-1][k]);
if(v[i][j]>0)for(int k=0;k<3;k++)dp[i][j][k+1]=max(dp[i][j][k+1],dp[i][j-1][k]+v[i][j]);
}
if(i>1){
for(int k=0;k<4;k++)dp[i][j][0]=max(dp[i][j][0],dp[i-1][j][k]);
if(v[i][j]>0)for(int k=0;k<4;k++)dp[i][j][1]=max(dp[i][j][1],dp[i-1][j][k]+v[i][j]);
}
}
ll ans=0;
for(int i=0;i<4;i++)ans=max(ans,dp[n][m][i]);
cout<<ans;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int R, C, K;
int val[3000][3000];
ll memo[3000][3000][4];
bool visited[3000][3000][4];
ll f(int x, int y, int z) {
if (x >= R || y >= C) return 0;
if (visited[x][y][z]) return memo[x][y][z];
visited[x][y][z] = true;
auto r = f(x+1, y, 0) + (z < 3 ? val[x][y] : 0);
if (z < 3 && val[x][y]) r = max(r, f(x, y+1, z+1) + val[x][y]);
r = max(r, f(x, y+1, z));
return memo[x][y][z] = r;
}
int main() {
cin >> R >> C >> K;
for (int i = 0; i < K; ++ i) {
int r, c, v;
cin >> r >> c >> v;
-- r; -- c;
val[r][c] = v;
}
cout << f(0, 0, 0) << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
long long x[3005][3005], dp[3005][3005][4], ans;
int main() {
scanf("%d%d%d", &n, &m, &k);
while (k--) {
int ta, tb;
long long tc;
scanf("%d%d%lld", &ta, &tb, &tc);
x[ta][tb] += tc;
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
for (int ii = 0; ii <= 3; ii++) {
dp[i][j][ii] = max(dp[i][j - 1][ii], dp[i - 1][j][3]);
if (ii)
dp[i][j][ii] = max(dp[i][j][ii], max(dp[i][j - 1][ii - 1], dp[i - 1][j][3]) + x[i][j]);
}
}
printf("%lld\n", dp[n][m][3]);
}
|
#include<bits/stdc++.h>
#define maxn 3005
using namespace std;
int arr[maxn][maxn];
long long dp[maxn][maxn][4];
long long get(int i,int j) {
return max({dp[i][j][0],dp[i][j][1],dp[i][j][2],dp[i][j][3]});
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int r,c,n;
cin >> r >> c >> n;
for(int i=1;i<=n;i++) {
int x,y,v;
cin >> x >> y >> v;
arr[x][y] = v;
}
for(int i=1;i<=r;i++)
for(int j=1;j<=c;j++) {
dp[i][j][0] = max(get(i - 1,j), dp[i][j - 1][0]);
for(int k=1;k<=3;k++)
dp[i][j][k] = max({dp[i][j - 1][k],dp[i][j - 1][k - 1] + arr[i][j],get(i - 1,j) + arr[i][j]});
}
cout << get(r,c) << endl;
return 0;
}
|
#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
typedef long long ll;
#define rep(i,n) for(int i=0;i<n;i++)
int a[3005][3005];
ll dp[3005][3005][4];
int main()
{
int R,C;
int K;
cin>>R>>C;
cin>>K;
rep(i,K)
{
int r,c,v;
cin>>r>>c>>v;
a[r-1][c-1]=v;
}
for(int i=0;i<R;i++)
{
for(int j=0;j<C;j++)
{
for(int k=2;k>=0;k--)
dp[i][j][k+1]=max(dp[i][j][k+1],dp[i][j][k]+a[i][j]);
for(int k=3;k>=0;k--)
{
dp[i][j+1][k]=max(dp[i][j+1][k],dp[i][j][k]);
dp[i+1][j][0]=max(dp[i+1][j][0],dp[i][j][k]);
}
}
}
ll ans=0;
for(int i=0;i<4;i++)
ans=max(ans,dp[R-1][C-1][i]);
cout <<ans;
return 0;
}
|
#include<bits/stdc++.h>
typedef long long ll;
using namespace std;
const int N=3e3+5;
ll r,c,k,x,y,z,g[N][N],dp[N][N][4];
int main()
{
cin>>r>>c>>k;
while(k--){
cin>>x>>y>>z;
g[x][y]=z;
}
for(int i=1;i<=r;i++){
for(int j=1;j<=c;j++){
for(int k=1;k<=3;k++){
dp[i][j][k]=max(dp[i-1][j][3]+g[i][j],max(dp[i][j-1][k-1]+g[i][j],dp[i][j-1][k]));
}
}
}
cout<<dp[r][c][3];
}
|
#include <bits/stdc++.h>
#define rep(i,n) for(int i = 0; i < (int)(n); ++i)
#define MOD 1000000007
using namespace std;
using ll = long long;
ll dp[3001][3001][4] = {};
ll mp[3001][3001] = {};
ll dpm(int dpi, int dpj, int dpk) {
ll x = dp[dpi][dpj][0];
rep (dpr, dpk+1) x = max(x, dp[dpi][dpj][dpr]);
return x;
}
int main() {
int r, c, n;
cin >> r >> c >> n;
rep(i,n) {
int h, w, v;
cin >> h >> w >> v;
mp[h][w] += v;
}
for (int i = 1; i <= r; i++) {
for (int j = 1; j <= c; j++) {
rep(k,4) {
if (k == 0) {
ll m = dpm(i-1, j, 3);
m = max(m, dp[i][j-1][0]);
dp[i][j][0] = m;
continue;
}
dp[i][j][k] = mp[i][j] + max(dp[i][j-1][k-1], dpm(i-1,j,3));
dp[i][j][k] = max(dp[i][j][k], dp[i][j-1][k]);
}
}
}
ll m = dpm(r, c, 3);
ll ans = m;
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 3000 + 7;
int n;
int m;
int k;
ll a[N][N];
ll dp[N][N][4];
ll tot[N][N];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m >> k;
for (int i = 1; i <= k; i++) {
int r, c, x;
cin >> r >> c >> x;
a[r][c] = x;
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
for (int k = 1; k <= 3; k++) {
dp[i][j][k] = max(dp[i][j - 1][k], tot[i - 1][j] + a[i][j]);
dp[i][j][k] = max(dp[i][j][k], dp[i][j - 1][k - 1] + a[i][j]);
}
for (int k = 1; k <= 3; k++) {
tot[i][j] = max(tot[i][j], dp[i][j][k]);
}
}
}
cout << tot[n][m] << "\n";
return 0;
}
|
#include "bits/stdc++.h"
using namespace std;
using ll = long long;
const int mx = 3000 + 9;
int R, C, K;
ll g[mx][mx];
ll dp[mx][mx][4];
ll solve(int i, int j, int k) {
if (i > R) return 0;
if (j > C) return 0;
ll& ans = dp[i][j][k];
if (ans != -1) return ans;
ans = 0;
if (k > 0) {
ans = max(ans, g[i][j] + solve(i, j + 1, k - 1));
ans = max(ans, g[i][j] + solve(i + 1, j, 3));
}
ans = max(ans, solve(i, j + 1, k));
ans = max(ans, solve(i + 1, j, 3));
return ans;
}
int main() {
scanf("%d %d %d", &R, &C, &K);
for (int i = 0; i < K; i++) {
int r, c; ll v;
scanf("%d %d %lld", &r, &c, &v);
g[r][c] = v;
}
memset(dp, -1, sizeof dp);
ll ans = solve(1, 1, 3);
printf("%lld\n", ans);
}
|
#include<cstdio>
#include<algorithm>
#include<vector>
using namespace std;
typedef long long ll;
const int MAXN = 3e3 + 5;
const int MAXM = 3e3 + 5;
int a[MAXN][MAXN];
int main(void)
{
int n,m,d;
scanf("%d%d%d",&n,&m,&d);
for(int i=1; i<=d; ++i)
{
int x,y,v;
scanf("%d%d%d",&x,&y,&v);
a[x][y] = v;
}
static ll f[MAXN][MAXM][5];
for(int i=1; i<=n; ++i)
for(int j=1; j<=m; ++j)
{
ll lst = max(max(f[i-1][j][0], f[i-1][j][1]), max(f[i-1][j][2], f[i-1][j][3]));
f[i][j][0] = max(f[i][j-1][0], lst);
f[i][j][1] = max(f[i][j-1][1], f[i][j][0] + a[i][j]);
f[i][j][2] = max(f[i][j-1][2], f[i][j-1][1] + a[i][j]);
f[i][j][3] = max(f[i][j-1][3], f[i][j-1][2] + a[i][j]);
}
printf("%lld\n",max(max(f[n][m][0], f[n][m][1]), max(f[n][m][2], f[n][m][3])));
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define endl "\n"
ll g[3010][3010], dp[3010][3010][5];
int r,c,k,x,y;
ll solve(int rr, int cc, int cnt)
{
if(rr>r || rr<1 || cc>c || c<1) return 0;
if(dp[rr][cc][cnt]!= -1) return dp[rr][cc][cnt];
ll ans=0;
ans = max({solve(rr,cc+1,cnt), solve(rr+1, cc, 0), ans});
if(cnt<3)
ans = max({g[rr][cc]+solve(rr,cc+1,cnt+1), g[rr][cc]+solve(rr+1, cc, 0), ans});
dp[rr][cc][cnt]=ans;
return ans;
}
int main()
{
memset(dp, -1, sizeof(dp));
cin>>r>>c>>k;
for(int i=0; i<k; i++)
{
cin>>x>>y;
cin>>g[x][y];
}
cout<<solve(1,1,0);
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main()
{
ios::sync_with_stdio(0);
cin.tie(0);
int r,c,k;
cin >> r >> c >> k;
vector<vector<int>> v(r+1,vector<int>(c+1,0));
for(int i=0;i<k;i++)
{
int a,b,w;
cin >> a >> b >> w;
v[a][b]=w;
}
vector<array<ll,4>> now(c+1,{0,0,0,0});
for(int o=1;o<=r;o++)
{
vector<array<ll,4>> nxt(c+1,{0,0,0,0});
for(int i=1;i<=c;i++)
{
nxt[i][0]=max(max({now[i][0],now[i][1],now[i][2],now[i][3]}),nxt[i-1][0]);
for(int j=3;j>=1;j--) nxt[i][j]=max(nxt[i-1][j],max(nxt[i-1][j-1],nxt[i][j-1])+v[o][i]);
}
now=nxt;
}
ll res=0;
for(int j=0;j<=3;j++) res=max(res,now[c][j]);
cout << res << "\n";
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
int a[3010][3010];
long long dp[3010][3010][4];
int n,m,k;
int main()
{
scanf("%d%d%d",&n,&m,&k);
int x,y,c;
for(int i=1;i<=k;i++)
{
scanf("%d%d%d",&x,&y,&c);
a[x][y]=c;
}
for(int i=1;i<=n;i++)
{
for(int j=1;j<=m;j++)
{
dp[i][j][0]=max(dp[i][j-1][0],max(max(dp[i-1][j][0],dp[i-1][j][1]),max(dp[i-1][j][2],dp[i-1][j][3])));
dp[i][j][1]=max(dp[i][j-1][0],max(max(dp[i-1][j][0],dp[i-1][j][1]),max(dp[i-1][j][2],dp[i-1][j][3])))+a[i][j];
for(int k=1;k<=3;k++)
{
dp[i][j][k]=max(dp[i][j][k],dp[i][j-1][k]);
dp[i][j][k]=max(dp[i][j][k],dp[i][j-1][k-1]+a[i][j]);
}
}
}
printf("%lld\n",max(max(dp[n][m][0],dp[n][m][1]),max(dp[n][m][2],dp[n][m][3])));
}
|
#include <bits/stdc++.h>
#define ll long long
#define ld long double
using namespace std;
const int N = 3e3 + 5, mod = 1e9 + 7;
ll a[N][N], dp[N][N][4];
int mark[N][N][4], n, m, k;
ll solve(int r, int c, int kam){
if(r >= n || c >= m || kam >= 3) return 0;
if(mark[r][c][kam]) return dp[r][c][kam];
mark[r][c][kam] = 1;
ll op1 = a[r][c] + solve(r, c + 1, kam + 1);
ll op2 = solve(r, c + 1, kam);
ll op3 = a[r][c] + solve(r + 1, c, 0);
return dp[r][c][kam] = max({op1, op2, op3});
}
int main(){
ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);
cin >> n >> m >> k;
for(int i = 0; i < k; i++){
int x, y, val;
cin >> x >> y >> val;
x--;
y--;
a[x][y] = val;
}
cout << solve(0, 0, 0);
return 0;
}
|
#include <bits/stdc++.h>
#define roop(i, n) for(int i = 0; i < (n); i++)
using namespace std;
using ll = long long;
using P = pair<int, int>;
#define chmax(x, y) x = max(x, y)
int a[3005][3005];
ll dp[3005][3005][4];
int main() {
int R, C, K;
cin >> R >> C >> K;
roop(i, K){
int r, c, v;
cin >> r >> c >> v;
a[r - 1][c - 1] = v;
}
roop(i, R){
roop(j, C){
for(int k = 2; k >= 0; k--){
chmax(dp[i][j][k + 1], dp[i][j][k] + a[i][j]);
}
roop(k, 4){
chmax(dp[i + 1][j][0], dp[i][j][k]);
chmax(dp[i][j + 1][k], dp[i][j][k]);
}
}
}
ll ans = 0;
roop(k, 4){
chmax(ans, dp[R - 1][C - 1][k]);
}
cout << ans << endl;
return 0;
}
|
#include<bits/stdc++.h>
#define MAX 3000
#define MOD 1000000007
using namespace std;
int r,c,k;
int v[MAX+1][MAX+1];
long long dp[MAX+1][MAX+1][4];
bool valid(int x,int y)
{
return (x>=1&&x<=r&&y>=1&&y<=c);
}
long long go(int x,int y,int used)
{
if(!valid(x,y))
return 0;
if(dp[x][y][used]^-1)
return dp[x][y][used];
long long a = 0, c = 0;
if(used<3)
a = v[x][y]*1LL+go(x,y+1,used+1), c = v[x][y]*1LL+go(x+1,y,0);
long long b = go(x,y+1,used), d = go(x+1,y,0);
return dp[x][y][used]=max({a,b,c,d});
}
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin>>r>>c>>k;
for(int i=1;i<=r;++i)
for(int j=1;j<=c;++j)
for(int t=0;t<4;++t)
dp[i][j][t] = -1;
while(k--)
{
int x,y,w;
cin>>x>>y>>w;
v[x][y] = w;
}
cout<<go(1,1,0)<<endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define int long long
const int N = 3003;
int dp[N][N][4], r, c;
int v[N][N];
int f(int i, int j, int k) {
if(i == r && j == c) {
if(!k) return 0;
return v[i][j];
}
int res = 0;
if(~dp[i][j][k]) {
return dp[i][j][k];
}
if(i + 1 <= r) {
res = max(res, f(i + 1, j, 3));
if(k) {
res = max(res, f(i + 1, j, 3) + v[i][j]);
}
}
if(j + 1 <= c) {
res = max(res, f(i, j + 1, k));
if(k) {
res = max(res, f(i, j + 1, k - 1) + v[i][j]);
}
}
return dp[i][j][k] = res;
}
int32_t main() {
ios_base :: sync_with_stdio(0); cin.tie(0); cout.tie(0);
int k; cin >> r >> c >> k;
for(int i = 1; i <= k; i++) {
int x, y, z; cin >> x >> y >> z;
v[x][y] += z;
}
memset(dp, -1, sizeof dp);
cout << f(1, 1, 3) << endl;
}
|
#include<bits/stdc++.h>
#define pf printf
#define sc(x) scanf("%d",&x);
#define scs(x) scanf("%s",x);
#define scl(x) scanf("%lld",&x);
#define rep(i,s,e) for(int i=s; i<=e; ++i)
#define dep(i,s,e) for(int i=s; i>=e; --i)
typedef long long ll;
using namespace std;
const int Max=2e5+5;
ll a[3005][3005];
int main()
{
ll r,c,k;
scl(r);scl(c);scl(k);
for(ll i=1;i<=k;i++){
ll u,v,co;scl(u);scl(v);scl(co);
a[u][v]=co;
}ll maxx=0;
for(int i=1;i<=r;i++){
ll max1=0,max2=0,max3=0;
for(int j=1;j<=c;j++){
max3=max(max3,max2+a[i][j]);max2=max(max2,max1+a[i][j]);max1=max(max1,a[i-1][j]+a[i][j]);
a[i][j]=max(max1,max(max2,max3));maxx=max(maxx,a[i][j]);
}
}pf("%lld\n",maxx);
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
ll dp[3001][3001][3], a[3001][3001];
ll func(int r, int c, int cnt) {
if(r < 0 || c < 0 || cnt < 0) return 0;
if(dp[r][c][cnt] != -1) return dp[r][c][cnt];
return dp[r][c][cnt] = max({func(r-1, c, 2) + a[r][c], func(r, c-1, cnt), func(r, c-1, cnt-1) + a[r][c]});
}
int main() {
ll r,c,items, x , y, v, maxi = 0;
cin >> r >> c >> items;
while(items--) {
cin >> x >> y >> v;
a[x-1][y-1]=v;
}
for(int i=0;i<r;i++) for(int j=0;j<c;j++) for(int k=0;k<4;k++) dp[i][j][k] = -1;
maxi = func(r-1, c-1, 2);
cout << maxi;
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
#define int long long
const int N = 3333;
int dp[N][N][6];
/*dp(i,j,k)：当前位于 第 i 行,第 j 列,且当行已经取了第 k 个的最大值 */
int mp[N][N]={0};
int R,C,K;
int mc[N];
signed main(){
cin>>R>>C>>K;
int r,c,v;
for(int i=1;i<=K;i++){
cin>>r>>c>>v;
mp[r][c]=v;
}
for(int i=1;i<=R;i++){
for(int j=1;j<=C;j++){
int sum=0;
for(int k=0;k<=3;k++){
sum=max(sum,dp[i-1][j][k]);
}
for(int k=1;k<=3;k++){
dp[i][j][k]=max(max(dp[i][j-1][k],dp[i][j-1][k-1]+mp[i][j]),sum+mp[i][j]);
}
}
}
int ans=0;
for(int i=0;i<=3;i++){
ans=max(ans,dp[R][C][i]);
}
cout<<ans;
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
int n,m,t;
int a[3005][3005];
long long dp[3005][3005][4];
int main(){
scanf("%d %d %d",&n,&m,&t);
for(int i=0;i<t;i++){
static int r,c,v;
scanf("%d %d %d",&r,&c,&v);
a[r][c]=v;
}
for(int i=1;i<=n;i++){
for(int j=1;j<=m;j++){
dp[i][j][0]=*max_element(dp[i-1][j],dp[i-1][j]+4);
dp[i][j][1]=max(max(dp[i][j-1][0],dp[i][j][0])+a[i][j],dp[i][j-1][1]);
dp[i][j][2]=max(dp[i][j-1][1]+a[i][j],dp[i][j-1][2]);
dp[i][j][3]=max(dp[i][j-1][2]+a[i][j],dp[i][j-1][3]);
}
}
printf("%lld\n",*max_element(dp[n][m],dp[n][m]+4));
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
using UL = unsigned int;
using ULL = unsigned long long;
using LL = long long;
#define rep(i,n) for(int i=0; i<(n); i++)
int H,W;
int K;
LL G[3000][3000];
LL dp[3000][3000][4];
int main() {
scanf("%d%d%d",&H,&W,&K);
rep(y,H) rep(x,W) G[y][x]=0;
rep(k,K){
int y,x,v; scanf("%d%d%d",&y,&x,&v); y--; x--;
G[y][x] = v;
}
rep(y,H)rep(x,W)rep(i,4) dp[y][x][i]=0;
dp[0][0][1] = G[0][0];
rep(y,H)rep(x,W)rep(i,4){
if(y!=H-1) dp[y+1][x][0] = max(dp[y+1][x][0],dp[y][x][i]);
if(y!=H-1) dp[y+1][x][1] = max(dp[y+1][x][1],dp[y][x][i]+G[y+1][x]);
if(x!=W-1) dp[y][x+1][i] = max(dp[y][x+1][i],dp[y][x][i]);
if(x!=W-1)if(i!=3) dp[y][x+1][i+1] = max(dp[y][x+1][i+1],dp[y][x][i]+G[y][x+1]);
}
LL ans=0;
rep(i,4) ans=max(ans,dp[H-1][W-1][i]);
cout<<ans<<endl;
return 0;
}
|
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
#define rrep(i, n) for (int i = (n - 1); i >= 0; i--)
#define ALL(v) v.begin(), v.end()
using namespace std;
using P = pair<int, int>;
typedef long long ll;
ll dp[3030][3030][4];
ll T[3030][3030];
int main() {
int R, C, K;
cin >> R >> C >> K;
rep(i, K) {
int r, c;
ll v;
cin >> r >> c >> v;
r--, c--;
T[r][c] = v;
}
rep(i, R) {
rep(j, C) {
for(int k = 2; k >= 0; k--){
dp[i][j][k + 1] = max(dp[i][j][k] + T[i][j], dp[i][j][k+1]);
}
rep(k, 4) {
dp[i][j + 1][k] = max(dp[i][j][k], dp[i][j + 1][k]);
dp[i+1][j][0] = max(dp[i][j][k], dp[i+1][j][0]);
}
}
}
ll ans = 0;
rep(i, 4) {
ans = max(ans, dp[R-1][C-1][i]);
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int sz = 3005;
int r, c, k, a[sz][sz];
ll dp[sz][sz][4];
ll fnc(int x, int y, int d) {
if(x == r && y == c) {
if(d) return a[x][y];
return 0;
}
ll &w = dp[x][y][d];
if(w < 0) {
w = 0;
if(y < c) w = max(w, fnc(x, y+1, d));
if(x < r) w = max(w, fnc(x+1, y, 3));
if(d && a[x][y]) {
if(y < c) w = max(w, a[x][y] + fnc(x, y+1, d-1));
if(x < r) w = max(w, a[x][y] + fnc(x+1, y, 3));
}
}
return w;
}
int main() {
cin >> r >> c >> k;
while(k--) {
int x, y, v;
scanf("%d %d %d", &x, &y, &v);
a[x][y] = v;
}
memset(dp, -1, sizeof(dp));
cout << fnc(1, 1, 3) << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
#define int long long
template<typename T>
void chmax(T &a,T b){
if(a<b)a=b;
}
int R,C,K,r,c,v,d[3123][3123],memo[3123][3123][5];
int f(int y,int x,int cnt){
if(y<0||x<0)return 0;
if(~memo[y][x][cnt])return memo[y][x][cnt];
int res=0;
for(int i=0;i<=3;i++)chmax(res,f(y-1,x,i));
for(int i=0;i<=cnt;i++)chmax(res,f(y,x-1,i));
if(cnt)for(int i=0;i<=3;i++)chmax(res,f(y-1,x,i)+d[y][x]);
if(cnt)chmax(res,f(y,x-1,cnt-1)+d[y][x]);
return memo[y][x][cnt]=res;
}
signed main(){
memset(memo,-1,sizeof(memo));
cin>>R>>C>>K;
while(K--){
cin>>r>>c>>v;
d[r][c]=v;
}
cout<<f(R+1,C+1,0)<<endl;
}
|
// Originalcode: https://atcoder.jp/contests/abc175/submissions/15970101
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define all(v) v.begin(), v.end()
#define ll int64_t
#define _GLIBCXX_DEBUG
ll dp[3005][3005][5];
ll m[3005][3005];
int main(){
int r,c,k;
cin >> r >> c >> k;
rep(i,k){
int a,b;
ll x;
cin >>a>>b>>x;
m[a][b]=x;
}
rep(i,r){
rep(j,c){
dp[i+1][j+1][0]=max(dp[i][j+1][4],dp[i+1][j][0]);
for(int p=1;p<4;p++)
dp[i+1][j+1][p+1]=max(dp[i][j+1][4]+m[i+1][j+1],max(dp[i+1][j][p]+m[i+1][j+1],dp[i+1][j][p+1]));
}
}
cout << dp[r][c][4] << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int M = 3e3;
int mat[M][M], n, m;
long long memo[M][M][4];
long long solve(int i, int j, int cnt) {
if (i == n || j == m)
return 0;
long long &result = memo[i][j][cnt];
if (result == -1) {
result = max(solve(i + 1, j, 0), solve(i, j + 1, cnt));
if (cnt < 3)
result = max(result, mat[i][j] + max(solve(i + 1, j, 0), solve(i, j + 1, cnt + 1)));
}
return result;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
memset(memo, -1, sizeof memo);
int k;
cin >> n >> m >> k;
while (k--) {
int x, y, val;
cin >> x >> y >> val;
x--;
y--;
mat[x][y] = val;
}
cout << solve(0, 0, 0) << '\n';
}
|
#include<bits/stdc++.h>
using namespace std;
const int maxn=3009;
int n,m,K;
int a[maxn][maxn];
long long f[maxn][maxn][4];
int main(){
cin>>n>>m>>K;
while(K--){
int x,y,z;scanf("%d%d%d",&x,&y,&z);
a[x][y]=z;
}
for(int i=1;i<=n;++i){
for(int j=1;j<=m;++j){
for(int k=0;k<=3;++k){
long long t=max(max(f[i-1][j][0],f[i-1][j][1]),max(f[i-1][j][2],f[i-1][j][3]));
f[i][j][k]=max(f[i][j-1][k],t);
if(k)f[i][j][k]=max(f[i][j-1][k-1]+a[i][j],f[i][j][k]);
if(k)f[i][j][k]=max(f[i][j][k],t+a[i][j]);
}
}
}
printf("%lld\n",max(max(f[n][m][0],f[n][m][1]),max(f[n][m][2],f[n][m][3])));
return 0;
}
|
#include <iostream>
#include<bits/stdc++.h>
using namespace std;
const int n=3000;
long long int dp[3000][3000][4];
long long int a[3000][3000];
long long int fun(long int x,long int y,long int z)
{
//cout<<x<<" "<<y<<" "<<z<<endl;
if(x<0 || y<0)
return 0;
if(dp[x][y][z]!=-1)
return dp[x][y][z];
dp[x][y][z]=max(fun(x-1,y,3),fun(x,y-1,z));
if(z>0)
dp[x][y][z]=max(dp[x][y][z],a[x][y]+max(fun(x-1,y,3),fun(x,y-1,z-1)));
return dp[x][y][z];
}
int main() {
long int r,c,k;
cin>>r>>c>>k;
memset(dp,-1,sizeof(dp));
memset(a,0,sizeof(a));
long int aa,bb,cc;
for(long int i=0;i<k;i++)
{
cin>>aa>>bb>>cc;
a[aa-1][bb-1]=cc;
}
cout<<fun(r-1,c-1,3);
//goes here
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define SZ(a) ((int)(a).size())
typedef long long int64;
int64 dp[3333][3333][4],v[3333][3333];
int main(){
#ifdef LOCAL
freopen(".a.in", "r", stdin);
#endif
ios_base::sync_with_stdio(false),cout.tie(0),cin.tie(0);
int n,m,k;cin>>n>>m>>k;
for(int i=0;i<k;++i){
int x,y;cin>>x>>y;
cin>>v[x][y];
}
for(int i=1;i<=n;++i){
for(int j=1;j<=m;++j){
if(v[i][j]){
for(int a=3;a;--a)dp[i][j][a]=max(dp[i][j][a-1]+v[i][j],dp[i][j][a]);
}
for(int a=0;a<=3;++a)dp[i+1][j][0]=max(dp[i][j][a],dp[i+1][j][0]);
for(int a=0;a<=3;++a)dp[i][j+1][a]=max(dp[i][j][a],dp[i][j+1][a]);
}
}
int64 res=dp[n][m][0];
for(int a=0;a<=3;++a)res=max(res,dp[n][m][a]);
cout<<res<<'\n';
return 0;
}
//2020.08.15 21:02:54
|
#include<bits/stdc++.h>
using namespace std;
using ll = long long;
int n, m, k;
ll a[3030][3030], dp[3030][3030][4];
int main(){
ios_base::sync_with_stdio(0);cin.tie(0);
cin >> n >> m >> k;
for(int i=1;i<=k;i++){
int x, y, v; cin >> x >> y >> v;
a[x][y] = v;
}
for(int i=1;i<=n;i++){
for(int j=1;j<=m;j++){
for(int k=0;k<=3;k++){
dp[i][j][0] = max(dp[i][j][0], dp[i-1][j][k]);
if(a[i][j]) dp[i][j][1] = max(dp[i][j][1], dp[i-1][j][k] + a[i][j]);
dp[i][j][k] = max(dp[i][j][k], dp[i][j-1][k]);
if(a[i][j] && k <= 2) dp[i][j][k+1] = max(dp[i][j][k+1], dp[i][j-1][k] + a[i][j]);
}
}
}
cout << max({dp[n][m][3], dp[n][m][2], dp[n][m][1], dp[n][m][0]});
}
|
#include<bits/stdc++.h>
#define LL long long
using namespace std;
LL dp[3005][3005][4];
int a[3005][3005];
int r,c;
int main()
{
int i,j,k;
scanf("%d%d%d",&r,&c,&k);
while(k--)
{
int t1,t2,t3;
scanf("%d%d%d",&t1,&t2,&t3);
a[t1][t2]=t3;
}
for(i=1;i<=r;i++)
for(j=1;j<=c;j++)
{
for(k=0;k<4;k++)
dp[i][j][0]=max(dp[i][j][0],dp[i-1][j][k]);
for(k=0;k<4;k++)
dp[i][j][k]=max(dp[i][j][k],dp[i][j-1][k]);
if(a[i][j])
{
for(k=0;k<4;k++)
dp[i][j][1]=max(dp[i][j][1],dp[i-1][j][k]+a[i][j]);
for(k=1;k<4;k++)
dp[i][j][k]=max(dp[i][j][k],dp[i][j-1][k-1]+a[i][j]);
}
}
LL ans=0;
for(k=0;k<4;k++)
ans=max(ans,dp[r][c][k]);
printf("%lld",ans);
return 0;
}
|
#import<bits/stdc++.h>
#define endl '\n'
using namespace std;
typedef long long LL;
LL i,j,k,m,n,s,v,x,y,e[3018][3018],f[3018][3018],g[3018][3018],h[3018][3018],p[3018][3018];
int main()
{
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin>>n>>m>>k;
for(;i++<k;)
{
cin>>x>>y>>v;
p[x][y]=v;
}
for(i=0;i++<n;)
{
for(j=0;j++<m;)
{
v=max(max(e[i-1][j],f[i-1][j]),max(g[i-1][j],h[i-1][j]));
if(p[i][j])
{
e[i][j]=max(e[i][j-1],v);
f[i][j]=max(f[i][j-1],e[i][j]+p[i][j]);
g[i][j]=max(g[i][j-1],f[i][j-1]+p[i][j]);
h[i][j]=max(h[i][j-1],g[i][j-1]+p[i][j]);
}
else
{
e[i][j]=max(e[i][j-1],v);
f[i][j]=f[i][j-1];
g[i][j]=g[i][j-1];
h[i][j]=h[i][j-1];
}
}
}
cout<<max(max(e[n][m],f[n][m]),max(g[n][m],h[n][m]));
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int R,C,K;
cin>>R>>C>>K;
vector<vector<int64_t>> p(R,vector<int64_t>(C));
for(int i=0;i<K;i++){
int a,b;
int64_t c;
cin>>a>>b>>c;
a--,b--;
p[a][b]=c;
}
vector<int64_t> dp(C);
for(int i=0;i<R;i++){
vector<int64_t> ndp(C);
vector<int64_t> kdp(4);
for(int j=0;j<C;j++){
kdp[0]=max(kdp[0],dp[j]);
ndp[j]=kdp[0];
for(int k=2;k>=0;k--){
kdp[k+1]=max(kdp[k+1],kdp[k]+p[i][j]);
ndp[j]=max(ndp[j],kdp[k+1]);
}
}
dp=ndp;
}
cout<<dp[C-1]<<endl;
}
|
#include<bits/stdc++.h>
using namespace std;
long long val[4000][4000];
long long dp[3001][3001][4];
long long max_val(long long r,long long c, long long cnt)
{
if(r<0 || c<0)
return 0;
if(dp[r][c][cnt]!=-1)
return dp[r][c][cnt];
long long c1=0, c2=0;
if(cnt>0)
c1 = max(max_val(r-1,c,3),max_val(r,c-1,cnt-1)) + val[r][c];
c2 = max(max_val(r-1,c,3),max_val(r,c-1,cnt));
dp[r][c][cnt] = max(c1,c2);
return dp[r][c][cnt];
}
int main()
{
long long r,c,k;
cin>>r>>c>>k;
for (int i = 0; i <= r; ++i)
{
for(int j = 0; j <= c ;j++)
{
for (int h = 0; h < 4; ++h)
{
dp[i][j][h] = -1;
}
}
}
for (long long i = 0; i < k; ++i)
{
long long x,y,v;
cin>>x>>y>>v;
val[x-1][y-1] = v;
}
cout<<max_val(r-1,c-1,3)<<endl;
return 0;
}
|
#include <bits/stdc++.h>
#define rep(i,n) for(int i=0;i<n;i++)
using namespace std;
using ll = long long;
#define chmax(x,y) x = max(x,y)
int Item[3005][3005];
ll DP[3005][3005][4];
int main(){
int R,C,k;cin>>R>>C>>k;
rep(i,k){
int r,c,v;
scanf("%d %d %d",&r,&c,&v);
r--;c--;
Item[r][c]=v;
}
rep(i,R)rep(j,C){
for(int k=2;k>=0;k--){
chmax(DP[i][j][k+1],DP[i][j][k]+Item[i][j]);
}
rep(k,4){
chmax(DP[i+1][j][0],DP[i][j][k]);
chmax(DP[i][j+1][k],DP[i][j][k]);
}
}
ll ans=0;
rep(k,4)chmax(ans,DP[R-1][C-1][k]);
cout<<ans<<endl;
}
|
#include <bits/stdc++.h>
#define MOD 1000000007LL
using namespace std;
typedef long long ll;
typedef pair<int,int> P;
int r,c,k;
ll dp[3005][3005][4];
ll fie[3005][3005];
int main(void){
scanf("%d%d%d",&r,&c,&k);
for(int i=0;i<k;i++){
int a,b,c;
scanf("%d%d%d",&a,&b,&c);
a--;
b--;
fie[a][b]=c;
}
dp[0][0][0]=0;
for(int i=0;i<r;i++){
for(int j=0;j<c;j++){
for(int k=0;k<=3;k++){
dp[i+1][j][0]=max(dp[i+1][j][0],dp[i][j][k]);
dp[i][j+1][k]=max(dp[i][j+1][k],dp[i][j][k]);
if(k<3){
dp[i+1][j][0]=max(dp[i+1][j][0],dp[i][j][k]+fie[i][j]);
dp[i][j+1][k+1]=max(dp[i][j+1][k+1],dp[i][j][k]+fie[i][j]);
}
}
}
}
ll ans=0;
for(int i=0;i<=3;i++){
ans=max(ans,dp[r-1][c-1][i]);
if(i<3){
ans=max(ans,dp[r-1][c-1][i]+fie[r-1][c-1]);
}
}
printf("%lld\n",ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int MAX = 3050;
int r,c,k,x,y,val;
ll dp[MAX][MAX][4];
ll room[MAX][MAX];
int main() {
cin>>r>>c>>k;
while(k--){
cin>>x>>y>>val;
room[x][y]=val;
}
for(int i=1;i<=r;i++){
for(int j=1;j<=c;j++){
for(int k=1;k<=3;k++){
dp[i][j][k]=max(max(room[i][j]+dp[i-1][j][3],dp[i][j-1][k]),room[i][j]+dp[i][j-1][k-1]);
}
}
}
cout<<dp[r][c][3];
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
#define ll long long
int r,c,k;
int a[3005][3005];
ll dp[3005][3005][3];
ll f(int row,int col,int cnt)
{
ll &ret=dp[row][col][cnt];
if(row>r||col>c) ret=0;
if(ret!=-1) return ret;
ret=0;
if(a[row][col])
{
ret+=a[row][col];
if(cnt==2)
ret+=f(row+1,col,0);
else
ret+=max(f(row+1,col,0),f(row,col+1,cnt+1));
}
ret=max({ret,f(row+1,col,0),f(row,col+1,cnt)});
return ret;
}
int main(void)
{
cin>>r>>c>>k;
memset(a,0,sizeof(a));
memset(dp,-1,sizeof(dp));
for(int i=0;i<k;++i)
{
int row,col,val;
cin>>row>>col>>val;
a[row][col]=val;
}
cout<<f(1,1,0)<<endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define ll long long
ll n,m,k;
ll a[3000][3000];
ll dp[3000][3000][4];
ll solve(int i,int j,int rem){
if(i==n-1 && j==m-1){
if(a[i][j]!=0 && rem>=1) return a[i][j];
else return 0;
}
if(dp[i][j][rem]!=-1LL) return dp[i][j][rem];
ll req = 0;
if(j+1<m){
req = max(req,solve(i,j+1,rem));
if(rem>0 && a[i][j]!=0) req = max(req,a[i][j] + solve(i,j+1,rem-1));
}
if(i+1<n){
req = max(req,solve(i+1,j,3));
if(rem>0 && a[i][j]!=0) req = max(req,a[i][j] + solve(i+1,j,3));
}
dp[i][j][rem] = req;
return req;
}
int main() {
memset(a,0,sizeof(a));
memset(dp,-1LL,sizeof(dp));
cin>>n>>m>>k;
for(ll i=0;i<k;i++){
ll r,c,v;
cin>>r>>c>>v;
r--;c--;
a[r][c] = v;
}
cout<<solve(0,0,3)<<"\n";
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
#define ft ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);
#define ll long long
const int N=3e3+5;
ll a[N][N],dp[N][N][4],n,m;
ll go(ll i,ll j,ll k)
{
if(i==n+1 || j==m+1)
{
return 0;
}
else if(dp[i][j][k]!=-1)
{
return dp[i][j][k];
}
else if(k==3)
{
return go(i+1,j,0);
}
else
{
return dp[i][j][k]=max({go(i+1,j,0)+a[i][j],go(i,j+1,k+1)+a[i][j],go(i,j+1,k)});
}
}
int main()
{
ft
ll t,i,j,k,l,r,p;
cin>>n>>m>>k;
memset(a,0,sizeof(a));
memset(dp,-1,sizeof(dp));
for(i=0;i<k;i++)
{
cin>>l>>r>>p;
a[l][r]=p;
}
cout<<go(1,1,0)<<"\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define ll long long
int main() {
int r, c, k; cin >> r >> c >> k;
vector<vector<ll> > g1(r + 1, vector<ll> (c + 1)), g2(g1), g3(g2), g(g1);
for (int i = 0; i < k; ++i) {
int row, col, val; cin >> row >> col >> val;
g[row][col] = val;
}
g1[1][1] = g2[1][1] = g3[1][1] = g[1][1];
for (int i = 1; i <= r; ++i) {
for (int j = 1; j <= c; ++j) {
if (i > 1) {
g1[i][j] = g3[i-1][j] + g[i][j] ;
g2[i][j] = g1[i][j];
g3[i][j] = g2[i][j];
}
if (j > 1) {
g1[i][j] = max({g[i][j], g1[i][j-1], g1[i][j]});
g2[i][j] = max({g[i][j] + g1[i][j-1], g2[i][j], g2[i][j-1]});
g3[i][j] = max({g3[i][j], g[i][j] + g2[i][j-1], g3[i][j-1]});
}
}
}
cout << g3[r][c] << endl;
}
|
#include <bits/stdc++.h>
#define pb push_back
typedef long long ll;
using namespace std;
const int mx = 3e3;
ll dp[mx + 3][mx + 3][5];
ll arr[mx + 3][mx + 3];
int main() {
ll r, c, k;
cin >> r >> c >> k;
while (k--) {
ll x, y, v;
cin >> x >> y >> v;
arr[x][y] = v;
}
for (int i = 1; i <= r; ++i) {
for (int j = 1; j <= c; ++j) {
dp[i][j][0] = dp[i - 1][j][4];
dp[i][j][1] = max(dp[i][j - 1][1], max(dp[i - 1][j][4], dp[i][j - 1][0]) + arr[i][j]);
dp[i][j][2] = max(dp[i][j - 1][1] + arr[i][j], dp[i][j - 1][2]);
dp[i][j][3] = max(dp[i][j - 1][2] + arr[i][j], dp[i][j - 1][3]);
for (int k = 0; k < 4; ++k)
dp[i][j][4] = max(dp[i][j][k], dp[i][j][4]);
}
}
cout << dp[r][c][4] << endl;
}
|
#include <iostream>
using namespace std;
typedef long long ll;
#define chmax(x, y) x = max(x, y);
int V[3100][3100];
ll dp[3100][3100][5];
int main() {
int R, C, K; cin >> R >> C >> K;
for (int i = 0; i < K; i++) {
int r, c, v; cin >> r >> c >> v;
V[r-1][c-1] = v;
}
for (int i = 0; i < R; i++) {
for (int j = 0; j < C; j++) {
for (int k = 2; k >= 0; k--) {
chmax(dp[i][j][k+1], dp[i][j][k] + V[i][j]);
}
for (int k = 0; k < 4; k++) {
chmax(dp[i+1][j][0], dp[i][j][k]);
chmax(dp[i][j+1][k], dp[i][j][k]);
}
}
}
ll ans = 0;
for (int k = 0; k < 4; k++) chmax(ans, dp[R-1][C-1][k]);
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxN = 3009,INF=-10;
long long int dp[maxN][maxN][4],c[maxN][maxN];
int n,m;
long long int f(int i,int j,int d){
if(i<=0||j<=0||i>n||j>m||d<0)return INF;
if(i==n && j==m)return d?c[i][j]:0;
if(dp[i][j][d]!=-1)return dp[i][j][d];
long long int ret ;
if(d>0) ret = max( c[i][j] + max( f(i+1,j,3) , f(i,j+1,d-1) ) , f(i,j+1,d) );
else ret = max( f(i+1,j,3) , f(i,j+1,d) );
return dp[i][j][d]=ret;
}
int main(){
int k;
cin >> n >> m >> k ;
for(int i=0;i<k;i++){
int ni,mi,vi;
cin >> ni >> mi >> vi ;
c[ni][mi]=vi;
}
memset(dp,-1,sizeof(dp));
cout << f(1,1,3) << endl ;
}
|
#include<bits/stdc++.h>
using namespace std;
#define ll long long
ll g[4001][4001];
int r,c,k;
ll dp[4001][4001][4];
ll rec(ll i, ll j, ll taken)
{
if(i>=r)return 0;
if(j>=c)return 0;
if(dp[i][j][taken]!=-1)return dp[i][j][taken];
ll ans=0;
if(taken<3 && i<r && j<c){
ans=g[i][j];
}
else{ans=0;}
ans=rec(i+1,j,0);
if(taken<3){
ans=max(ans,rec(i+1,j,0)+g[i][j]);
}
ans=max(ans,rec(i,j+1,taken));
if(taken<3){
ans=max(ans,rec(i,j+1,taken+1)+g[i][j]);
}
return dp[i][j][taken]=ans;
}
int main()
{
cin>>r>>c>>k;
for(int i=0;i<r;i++)
{
for(int j=0;j<c;j++)
{
g[i][j]=0;
}
}
for(int i=0;i<k;i++)
{
int a,b,v; cin>>a>>b>>v;
a--; b--;
g[a][b]=v;
}
memset(dp,-1,sizeof(dp));
cout<<rec(0,0,0);
}
|
#include <iostream>
#include <cstdio>
#include <algorithm>
using namespace std;
#define endl '\n'
#define ll long long
#define pi pair<int, int>
#define f first
#define s second
const int mxn = 3001, w = 4;
int n, m, k;
ll a[mxn][mxn];
ll dp[mxn][mxn][w];
int main(){
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m >> k;
for(int i = 0; i < k; i++){
int x, y;
cin >> x >> y >> a[x][y];
}
for(int i = 1; i <= n; i++)
for(int j = 1; j <= m; j++){
dp[i][j][0] = max(dp[i][j - 1][0], dp[i - 1][j][w - 1]);
for(int l = 1; l < w; l++){
dp[i][j][l] = max({
dp[i - 1][j][w - 1] + a[i][j],
dp[i][j - 1][l],
dp[i][j - 1][l - 1] + a[i][j]
});
}
}
cout << dp[n][m][w - 1];
return 0;
}
|
#include <bits/stdc++.h>
#define fast ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);
#define int long long
#define endl "\n"
using namespace std;
int r, c, k;
int grid[3005][3005];
int dp[3005][3005][4]; //row col taken
int compute(int i,int j,int taken){
if(i>r || j>c)return 0;
int &ans=dp[i][j][taken];
if(ans!=-1)return ans;
if(taken>=3){
ans=max(compute(i+1,j,0),compute(i,j+1,taken));
}
else{
ans=max({compute(i+1,j,0)+grid[i][j],compute(i,j+1,taken+1)+grid[i][j],compute(i,j+1,taken)});
}
return ans;
}
int32_t main() {
fast
cin >> r >> c >> k;
int x, y, value;
for(int i = 0; i < k; i++) {
cin >> x >> y >> value;
grid[x][y] = value;
}
memset(dp,-1,sizeof dp);
int ans=compute(0,0,0);
cout << ans<< endl;
return 0;
}
|
#include <bits/stdc++.h>
#define rep(i, n) for(int i = 0; i < (n); i++)
using namespace std;
using ll = long long;
using P = pair<int, int>;
#define chmax(x, y) x = max(x, y)
int items[3001][3001];
ll dp[3001][3001][4];
int main() {
int R, C, K;
cin >> R >> C >> K;
rep(i, K) {
int r, c, v;
cin >> r >> c >> v;
items[r-1][c-1] = v;
}
rep(i, R) rep(j, C) {
for (int k = 2; k >= 0; --k) {
chmax(dp[i][j][k+1], dp[i][j][k] + items[i][j]);
}
rep(k, 4) {
chmax(dp[i][j+1][k], dp[i][j][k]);
chmax(dp[i+1][j][0], dp[i][j][k]);
}
}
ll ans = 0;
rep(k, 4) chmax(ans, dp[R-1][C-1][k]);
cout << ans << endl;
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
#define Maxn 4010
int R, C, K, x, y, z, cost[Maxn][Maxn];
long long f[Maxn][Maxn][4];
int main()
{
scanf("%d%d%d", &R, &C, &K);
for (int i=1; i<=K; i++)
{
scanf("%d%d%d", &x, &y, &z);
cost[x][y]=z;
}
for (int i=1; i<=R; i++)
for (int j=1; j<=C; j++)
{
for (int k=0; k<=3; k++) f[i][j][0]=max(f[i][j][0], f[i-1][j][k]);
for (int k=0; k<=3; k++) f[i][j][k]=max(f[i][j][k], f[i][j-1][k]);
if (cost[i][j])
{
for (int k=0; k<=3; k++) f[i][j][1]=max(f[i][j][1], f[i-1][j][k]+cost[i][j]);
for (int k=0; k<3; k++) f[i][j][k+1]=max(f[i][j][k+1], f[i][j-1][k]+cost[i][j]);
}
}
long long Res=0; for (int i=0; i<=3; i++) Res=max(Res, f[R][C][i]);
printf("%lld\n", Res);
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using P = pair<int, int>;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define chmax(x,y) x = max(x,y)
ll dp[3005][3005][4];
int A[3005][3005];
int main() {
int R,C,K;
cin >> R >> C >> K;
rep(i,K) {
int r,c,v;
cin >> r >> c >> v;
r--;
c--;
A[r][c]= v;
}
rep(i,R) rep(j,C) {
if(i > 0) {
rep(k,4){
chmax(dp[i][j][0], dp[i-1][j][k]);
}
}
if(j > 0){
rep(k,4){
chmax(dp[i][j][k], dp[i][j-1][k]);
}
}
int v = A[i][j];
if (v > 0) {
for(int k=3; k>0; k--){
chmax(dp[i][j][k], dp[i][j][k-1] + v);
}
}
}
ll ans = 0;
rep(k,4){
chmax(ans, dp[R-1][C-1][k]);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define REP(i, n) for (int i = 0; i < (int)(n); i++)
typedef long long ll;
typedef pair<int, int> P;
template <class T>
inline bool chmax(T& a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
int field[3005][3005];
ll dp[3005][3005][4];
int main() {
int R, C, n;
cin >> R >> C >> n;
REP(i, n) {
int r, c, v;
cin >> r >> c >> v, r--, c--;
field[r][c] = v;
}
REP(i, R) REP(j, C) {
for (int k = 2; k >= 0; k--) {
chmax(dp[i][j][k + 1], dp[i][j][k] + field[i][j]); //拾ったことの遷移
}
REP(k, 4) {
chmax(dp[i + 1][j][0], dp[i][j][k]);
chmax(dp[i][j + 1][k], dp[i][j][k]);
}
}
ll ans = 0;
REP(k, 4) chmax(ans, dp[R - 1][C - 1][k]);
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
long a[3333][3333], d[4], e[3333];
int main() {
int r, c, k;
cin >> r >> c >> k;
for(int i = 0; i < k; i++) {
int x, y, v;
cin >> x >> y >> v;
a[x - 1][y - 1] = v;
}
for(int i = 0; i < r; i++) {
fill(d, d + 4, 0);
for(int j = 0; j < c; j++) {
for(int l = 4; l--;) {
d[l] = max(d[l], e[j]);
if(l)
d[l] = max({d[l], d[l - 1] + a[i][j], e[j] + a[i][j]});
}
e[j] = d[3];
}
}
cout << d[3] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
ll R, C, K;
ll Dp[3001][3001][4], V[3001][3001];
#define maxupd(A, B) (A) = max((A), (B))
ll Res;
int main() {
cin >> R >> C >> K;
for (ll i = 0; i < K; ++i) {
ll r, c, v;
cin >> r >> c >> v;
V[r][c] = v;
}
for (ll r = 1; r <= R; ++r) {
for (ll c = 1; c <= C; ++c) {
for (ll k = 0; k <= 3; ++k) {
maxupd(Dp[r][c][0], Dp[r - 1][c][k]);
maxupd(Dp[r][c][k], Dp[r][c - 1][k]);
}
for (ll k = 2; k >= 0; --k) {
maxupd(Dp[r][c][k + 1], Dp[r][c][k] + V[r][c]);
}
}
}
for (ll k = 0; k <= 3; ++k) maxupd(Res, Dp[R][C][k]);
cout << Res << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T> bool chmax(T &u, const T z) { if (u < z) {u = z; return true;} else return false; }
template <typename T> bool chmin(T &u, const T z) { if (u > z) {u = z; return true;} else return false; }
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define ll long long
int a[3005][3005];
long long dp[3005][3005][4];
//解説写し
int main() {
int R,C,K;
cin>>R>>C>>K;
rep(i,K){
int r,c,v;
cin>>r>>c>>v;
a[r-1][c-1]=v;
}
rep(i,R)rep(j,C){
for(int k=2;k>=0;k--){
chmax(dp[i][j][k+1],dp[i][j][k]+a[i][j]);
}
rep(k,4){
chmax(dp[i+1][j][0],dp[i][j][k]);//次の行に行ったら、リセットしてk=0とする
chmax(dp[i][j+1][k],dp[i][j][k]);
}
}
ll ans=0;
rep(k,4)chmax(ans,dp[R-1][C-1][k]);
cout<<ans<<endl;
}
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i,a,b) for(long long i = (a); i < (b); i++)
#define all(a) a.begin(),a.end()
#define allr(a) a.rbegin(),a.rend()
using ll = long long;
ll dp[3001][3001][4];
void solve()
{
ll r,c,k;
cin>>r>>c>>k;
vector<vector<ll>> v(r+1,vector<ll>(c+1,0));
while(k--){
ll a,b;
cin>>a>>b;
ll x;
cin>>x;
v[a][b]=x;
}
dp[0][0][0]=0;
dp[1][1][0]=0;
for(ll i=1;i<=r;i++){
dp[i][1][0]=0;
}
for(ll i=1;i<=r;i++){
for(ll j=1;j<=c;j++)
{
for(ll k=1;k<=3;k++){
dp[i][j][k]=max(dp[i-1][j][3],dp[i][j-1][k]);
}
for(ll k=1;k<=3;k++){
dp[i][j][k]=max(dp[i][j][k],max(dp[i-1][j][3]+v[i][j],dp[i][j-1][k-1]+v[i][j]));
}
}
}
ll temp=0;
temp=dp[r][c][3];
cout<<temp;
}
int main(){
ll t;
//cin>>t;
t=1;
while(t--){
solve();
cout<<endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
#define x first
#define y second
#define mp make_pair
#define pb push_back
typedef long long ll;
const ll MOD = 1e9+7;
const ll INF = 1e9+5;
int n, m, k;
ll v[3005][3005];
ll memo[3005][3005][4];
ll dp(int x, int y, int h) {
if (x>n or y>m) return 0;
if (memo[x][y][h] != -1) return memo[x][y][h];
ll sol = 0;
if (v[x][y] and h) {
sol = max(sol, v[x][y] + max(dp(x+1, y, 3), dp(x, y+1, h-1)));
}
sol = max(sol, max(dp(x+1, y, 3), dp(x, y+1, h)));
return memo[x][y][h] = sol;
}
int main() {
memset(memo, -1, sizeof memo);
scanf("%d%d%d", &n, &m, &k);
for (int i=0 ; i<k ; i++) {
int x, y, w;
scanf("%d%d%d", &x, &y, &w);
v[x][y] = w;
}
printf("%lld\n", dp(1, 1, 3));
return 0;
}
|
#include<cstdio>
#include<iostream>
#include<string>
#include<algorithm>
#include<stdio.h>
#include<locale.h>
#include<math.h>
#include<set>
#include<stack>
#include<queue>
using namespace std;
int R,C,K;
int v[3002][3002]={};
long long int mae[3002]={};//前の行の最大スコア
long long int nw[3002][4]={};//今の行のスコア
int main()
{
scanf("%d %d %d",&R,&C,&K);
for(int i=0;i<K;i++)
{
int a,b,vl;
scanf("%d %d %d",&a,&b,&vl);
v[a][b]=vl;
}
for(int i=1;i<=R;i++)
{
for(int j=1;j<=C;j++)
{
for(int l=1;l<=3;l++)
{
nw[j][l]=max(nw[j-1][l],max(nw[j-1][l-1]+v[i][j],mae[j]+v[i][j]));
}
}
for(int j=1;j<=C;j++)
{
mae[j]=nw[j][3];
}
}
long long int ans=0;
printf("%lld",nw[C][3]);
}
|
#include<bits/stdc++.h>
using namespace std;
#define int long long
int a[3002][3002];
int dp[3003][3002][4];
int32_t main(){
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int r,c,k;
cin >> r >> c >> k;
for(int i = 1; i <= k; i++){
int x,y,c;
cin >> x >> y >> c;
a[x][y] = c;
}
for(int i = 1; i <= r; i++){
for(int j = 1; j <= c; j++){
for(int k = 0; k <= 3; k++){
dp[i][j][0] = max(dp[i][j][0], dp[i - 1][j][k]);
dp[i][j][1] = max(dp[i][j][1] , a[i][j] + dp[i - 1][j][k]);
}
dp[i][j][0] = max(dp[i][j][0],dp[i][j - 1][0]);
for(int k = 1; k <= 3; k++){
dp[i][j][k] = max({dp[i][j][k], a[i][j] + dp[i][j - 1][k - 1],dp[i][j - 1][k]});
}
}
}
cout << max({dp[r][c][0],dp[r][c][1],dp[r][c][2],dp[r][c][3]});
}
|
#include<bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
int H, W, K; cin >> H >> W >> K;
vector<vector<int>> v(H, vector<int>(W));
for (int i = 0; i < H; i++) for (int j = 0; j < W; j++) {
int r, c, x; cin >> r >> c >> x; r--, c--;
v[r][c] = x;
}
vector<vector<vector<ll>>> dp(H+1, vector<vector<ll>>(W+1, vector<ll>(4, 0)));
for (int i = H - 1; i >= 0; i--) {
for (int j = W - 1; j >= 0; j--) {
for (int k = 0; k < 4; k++) {
auto& res = dp[i][j][k];
res = max(res, dp[i][j+1][k]);
res = max(res, dp[i+1][j][0]);
if (k != 3) {
res = max(res, dp[i][j+1][k+1] + v[i][j]);
res = max(res, dp[i+1][j][0] + v[i][j]);
}
}
}
}
cout << dp[0][0][0] << endl;
}
|
#include<bits/stdc++.h>
using namespace std;
long long n,m,k,vl[3030][3030],dp[3030][3030][4];
int main()
{
cin>>n>>m>>k;
for(int i=0;i<k;i++)
{
long long a,b,c;
cin>>a>>b>>c;
vl[a][b]=c;
}
for(int i=1;i<=n;i++)
{
for(int j=1;j<=m;j++)
{
for(int k=0;k<=3;k++)
{
if(k!=3)
{
dp[i+1][j][0]=max(dp[i+1][j][0],dp[i][j][k]+vl[i][j]);
}
dp[i+1][j][0]=max(dp[i+1][j][0],dp[i][j][k]);
dp[i][j+1][k]=max(dp[i][j+1][k],dp[i][j][k]);
if(k!=3)
{
dp[i][j+1][k+1]=max(dp[i][j+1][k+1],dp[i][j][k]+vl[i][j]);
}
}
}
}
cout<<max(dp[n][m][0]+vl[n][m],max(dp[n][m][1]+vl[n][m],max(dp[n][m][2]+vl[n][m],dp[n][m][3])))<<endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int R,C,K;
cin>>R>>C>>K;
vector<vector<int64_t>> p(R,vector<int64_t>(C));
for(int i=0;i<K;i++){
int a,b;
int64_t c;
cin>>a>>b>>c;
a--,b--;
p[a][b]=c;
}
vector<vector<int64_t>> dp(R,vector<int64_t>(C));
for(int i=0;i<R;i++){
vector<int64_t> kdp(4);
for(int j=0;j<C;j++){
if(i!=0){
kdp[0]=max(kdp[0],dp[i-1][j]);
}
for(int k=2;k>=0;k--){
kdp[k+1]=max(kdp[k+1],kdp[k]+p[i][j]);
dp[i][j]=max(dp[i][j],kdp[k+1]);
}
}
}
cout<<dp[R-1][C-1]<<endl;
}
|
#include<bits/stdc++.h>
#define int long long
using namespace std;
int A[3100][3100],B[3100][3100][5];
signed main(){
int H,W,K;
cin>>H>>W>>K;
for(int i=0;i<K;i++){
int x,y,c;
cin>>x>>y>>c;
A[x-1][y-1]=c;
}
for(int i=0;i<H;i++){
B[i+1][0][0]=max({B[i+1][0][0],B[i][0][0],B[i][0][1],B[i][0][2],B[i][0][3]});
if(A[i][0])B[i+1][0][1]=B[i+1][0][0]+A[i][0];
for(int j=1;j<W;j++){
for(int k=0;k<4;k++)B[i+1][j][k]=B[i+1][j-1][k];
B[i+1][j][0]=max(B[i+1][j][0],max({B[i][j][0],B[i][j][1],B[i][j][2],B[i][j][3]}));
if(A[i][j])B[i+1][j][1]=max(B[i+1][j][1],B[i+1][j][0]+A[i][j]);
for(int k=0;k<3;k++)
if(B[i+1][j-1][k])B[i+1][j][k+1]=max(B[i+1][j][k+1],B[i+1][j-1][k]+A[i][j]);
}
}
cout<<max({B[H][W-1][0],B[H][W-1][1],B[H][W-1][2],B[H][W-1][3]})<<endl;
}
|
#include <bits/stdc++.h>
#define rep(i, n) for(int i = 0; i < (n); i++)
using namespace std;
using ll = long long;
using P = pair<int, int>;
#define chmax(x, y) x = max(x, y)
int a[3005][3005];
ll dp[3005][3005][4];
int main() {
int R, C, K;
cin >> R >> C >> K;
rep(i, K) {
int r, c, v;
cin >> r >> c >> v;
a[r-1][c-1] = v;
}
rep(i, R) rep(j, C) {
for (int k = 2; k >= 0; k--) {
chmax(dp[i][j][k+1], dp[i][j][k] + a[i][j]);
}
rep(k, 4) {
chmax(dp[i+1][j][0], dp[i][j][k]);
chmax(dp[i][j+1][k], dp[i][j][k]);
}
}
ll ans = 0;
rep(k, 4) chmax(ans, dp[R-1][C-1][k]);
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
#define rep(i,n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
using P = pair<int,int>;
#define chmax(x,y) x = max(x,y)
int a[3005][3005];
ll dp[3005][3005][4];
int main() {
int R, C, n;
cin >> R >> C >> n;
rep(i,n) {
int r, c, v;
cin >> r >> c >> v;
a[r-1][c-1] = v;
}
rep(i,R)rep(j,C) {
for (int k = 2; k >= 0; k--) {
chmax(dp[i][j][k+1], dp[i][j][k]+a[i][j]);
}
rep(k,4) {
chmax(dp[i+1][j][0], dp[i][j][k]);
chmax(dp[i][j+1][k], dp[i][j][k]);
}
}
ll ans = 0;
rep(k,4) chmax(ans, dp[R-1][C-1][k]);
cout << ans << endl;
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
long long r,c,k,x,y,v,ans;
long long m[3005][3005],f[3005][3005][5];
int main()
{
cin>>r>>c>>k;
for(int i=1;i<=k;++i)
{
cin>>x>>y>>v;
m[x][y]=v;
}
for(int i=1;i<=r;++i)
for(int j=1;j<=c;++j)
for(int k=1;k<=3;++k)
f[i][j][k]=max(f[i-1][j][3]+m[i][j],max(f[i][j-1][k-1]+m[i][j],f[i][j-1][k])),
ans=max(ans,f[i][j][k]);
cout<<ans;
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.