제출 #1361272

#제출 시각아이디문제언어결과실행 시간메모리
1361272altern23메기 농장 (IOI22_fish)C++20
35 / 100
1115 ms2162688 KiB
#include "fish.h"

#include <bits/stdc++.h>
using namespace std;

#define ll long long

long long max_weights(int N, int M, vector<int> X, vector<int> Y, vector<int> W) {
      vector <vector<ll>> ps(N+5, vector <ll> (N+5));

      for (int i = 0; i < M; i++) {
            X[i]++, Y[i]++;
            ps[X[i]][Y[i]] += W[i];
      }

      for (int i = 1; i <= N; i++) {
            for (int j = 1; j <= N; j++) {
                  ps[i][j] += ps[i-1][j]+ps[i][j-1]-ps[i-1][j-1];
            }
      }

      ll dp[N+5][N+5][2], pmx[N+5][N+5][2];

      memset(dp, -0x3f, sizeof(dp));
      memset(pmx, -0x3f, sizeof(pmx));
      
      dp[0][0][0] = 0;
      
      ll ans = 0;

      auto calc = [&](int i, int j, int x, int y) {
            return ps[j][y]-(x == 0 ? 0LL : ps[j][x-1])-(i == 0 ? 0LL : ps[i-1][y])+(i == 0 || x == 0 ? 0LL : ps[i-1][x-1]);
      };

      
      for (int i = 0; i <= N; i++) {
            if (i) {
                  for (int j = 0; j <= N; j++) {
                        dp[i][0][0] = max(dp[i][0][0], dp[i-1][j][0]);
                        dp[i][0][0] = max(dp[i][0][0], dp[i-1][j][1]);

                        // lanjut increasing
                        if (i < N && j) dp[i][j][0] = max(dp[i][j][0], pmx[i-1][j-1][0]+ps[i][j]-ps[i-1][j]);
                        
                        for (int k = 1; k <= N; k++) {
                              if (i < N) {
                                    // lanjut increasing
                                    // if (k >= j+1) dp[i][k][0] = max(dp[i][k][0], dp[i-1][j][0]+calc(i, i, j+1, k));
                                    // ubah dari decreasing menjadi increasing
                                    dp[i][k][0] = max(dp[i][k][0], dp[i-1][j][1]+calc(i, i, 1, k));
                              }
                              if (i > 1) {
                                    // dari increasing menjadi decreasing
                                    dp[i][k][1] = max(dp[i][k][1], dp[i-1][0][0]+calc(i, i, k, N));
                                    // lanjut decreasing
                                    if (k <= j-1) dp[i][k][1] = max(dp[i][k][1], dp[i-1][j][1]+calc(i, i, k, j-1));
                              }
                              ans = max(ans, dp[i][k][0]);
                              ans = max(ans, dp[i][k][1]);
                        }
                  }
            }
            if (i+1 <= N) {
                  pmx[i][0][0] = dp[i][0][0];
                  for (int j = 1; j <= N; j++) {
                        pmx[i][j][0] = max(pmx[i][j-1][0], dp[i][j][0]-(ps[i+1][j]-ps[i][j]));
                  }
            }
      }

      return ans;
}
#결과 실행 시간메모리채점기 출력
결과를 불러오는 중입니다…
#결과 실행 시간메모리채점기 출력
결과를 불러오는 중입니다…
#결과 실행 시간메모리채점기 출력
결과를 불러오는 중입니다…
#결과 실행 시간메모리채점기 출력
결과를 불러오는 중입니다…
#결과 실행 시간메모리채점기 출력
결과를 불러오는 중입니다…
#결과 실행 시간메모리채점기 출력
결과를 불러오는 중입니다…
#결과 실행 시간메모리채점기 출력
결과를 불러오는 중입니다…
#결과 실행 시간메모리채점기 출력
결과를 불러오는 중입니다…