Codeforces Round 980 div2 個人題解(A~D)
Dashboard - Codeforces Round 980 (Div. 2) - Codeforces
火車頭
#define _CRT_SECURE_NO_WARNINGS 1
#include <algorithm>
#include <array>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <chrono>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <unordered_map>
#include <utility>
#include <vector>
#define ft first
#define sd second
#define yes cout << "yes\n"
#define no cout << "no\n"
#define Yes cout << "Yes\n"
#define No cout << "No\n"
#define YES cout << "YES\n"
#define NO cout << "NO\n"
#define pb push_back
#define eb emplace_back
#define all(x) x.begin(), x.end()
#define all1(x) x.begin() + 1, x.end()
#define unq_all(x) x.erase(unique(all(x)), x.end())
#define unq_all1(x) x.erase(unique(all1(x)), x.end())
#define sort_all(x) sort(all(x))
#define sort1_all(x) sort(all1(x))
#define reverse_all(x) reverse(all(x))
#define reverse1_all(x) reverse(all1(x))
#define inf 0x3f3f3f3f
#define infll 0x3f3f3f3f3f3f3f3fLL
#define RED cout << "\033[91m"
#define GREEN cout << "\033[92m"
#define YELLOW cout << "\033[93m"
#define BLUE cout << "\033[94m"
#define MAGENTA cout << "\033[95m"
#define CYAN cout << "\033[96m"
#define RESET cout << "\033[0m"
// 紅色
#define DEBUG1(x) \
RED; \
cout << #x << " : " << x << endl; \
RESET;
// 綠色
#define DEBUG2(x) \
GREEN; \
cout << #x << " : " << x << endl; \
RESET;
// 藍色
#define DEBUG3(x) \
BLUE; \
cout << #x << " : " << x << endl; \
RESET;
// 品紅
#define DEBUG4(x) \
MAGENTA; \
cout << #x << " : " << x << endl; \
RESET;
// 青色
#define DEBUG5(x) \
CYAN; \
cout << #x << " : " << x << endl; \
RESET;
// 黃色
#define DEBUG6(x) \
YELLOW; \
cout << #x << " : " << x << endl; \
RESET;
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
// typedef __int128_t i128;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef pair<ld, ld> pdd;
typedef pair<ll, int> pli;
typedef pair<string, string> pss;
typedef pair<string, int> psi;
typedef pair<string, ll> psl;
typedef tuple<int, int, int> ti3;
typedef tuple<ll, ll, ll> tl3;
typedef tuple<ld, ld, ld> tld3;
typedef vector<bool> vb;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef vector<string> vs;
typedef vector<pii> vpii;
typedef vector<pll> vpll;
typedef vector<pli> vpli;
typedef vector<pss> vpss;
typedef vector<ti3> vti3;
typedef vector<tl3> vtl3;
typedef vector<tld3> vtld3;
typedef vector<vi> vvi;
typedef vector<vl> vvl;
typedef queue<int> qi;
typedef queue<ll> ql;
typedef queue<pii> qpii;
typedef queue<pll> qpll;
typedef queue<psi> qpsi;
typedef queue<psl> qpsl;
typedef priority_queue<int> pqi;
typedef priority_queue<ll> pql;
typedef priority_queue<string> pqs;
typedef priority_queue<pii> pqpii;
typedef priority_queue<psi> pqpsi;
typedef priority_queue<pll> pqpll;
typedef priority_queue<psi> pqpsl;
typedef map<int, int> mii;
typedef map<int, bool> mib;
typedef map<ll, ll> mll;
typedef map<ll, bool> mlb;
typedef map<char, int> mci;
typedef map<char, ll> mcl;
typedef map<char, bool> mcb;
typedef map<string, int> msi;
typedef map<string, ll> msl;
typedef map<int, bool> mib;
typedef unordered_map<int, int> umii;
typedef unordered_map<ll, ll> uml;
typedef unordered_map<char, int> umci;
typedef unordered_map<char, ll> umcl;
typedef unordered_map<string, int> umsi;
typedef unordered_map<string, ll> umsl;
std::mt19937_64 rng(std::chrono::steady_clock::now().time_since_epoch().count());
template <typename T>
inline T read()
{
T x = 0;
int y = 1;
char ch = getchar();
while (ch > '9' || ch < '0')
{
if (ch == '-')
y = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9')
{
x = (x << 3) + (x << 1) + (ch ^ 48);
ch = getchar();
}
return x * y;
}
template <typename T>
inline void write(T x)
{
if (x < 0)
{
putchar('-');
x = -x;
}
if (x >= 10)
{
write(x / 10);
}
putchar(x % 10 + '0');
}
/*#####################################BEGIN#####################################*/
void solve()
{
}
int main()
{
ios::sync_with_stdio(false), std::cin.tie(0), std::cout.tie(0);
// freopen("test.in", "r", stdin);
// freopen("test.out", "w", stdout);
int _ = 1;
std::cin >> _;
while (_--)
{
solve();
}
return 0;
}
/*######################################END######################################*/
// 連結：
A. Profitable Interest Rate
每個測試的時間限制：1秒
每個測試的記憶體限制：256兆位元組
Alice 有 \(a\) 個硬幣。她可以開立一個名為“盈利”的銀行存款，但開立此存款所需的最低金額為 \(b\) 個硬幣。
還有一個名為“無利可圖”的存款，可以用任意數量的硬幣開立。Alice 注意到，如果她用 \(x\) 個硬幣開立“無利可圖”存款，則開立“盈利”存款所需的最低金額會減少 \(2x\) 個硬幣。但是，這些硬幣以後不能存入“盈利”存款。
如果 Alice 首先將一定數量的硬幣（可能是 0）存入“無利可圖”存款，請幫助她確定她可以存入“盈利”存款的最大硬幣數量。如果 Alice 永遠無法開立“盈利”存款，則輸出 0。
輸入
每個測試由多個測試用例組成。第一行包含一個整數 \(t\) \((1 \leq t \leq 10^4)\) — 測試用例的數量。測試用例的描述如下。
每個測試用例的一行包含兩個整數 \(a\) 和 \(b\) \((1 \leq a, b \leq 10^9)\) — Alice 擁有的硬幣數量以及開立“盈利”存款所需的初始最低金額。
輸出
對於每個測試用例，輸出一個整數 — Alice 可以存入“盈利”存款的最大硬幣數量。如果 Alice 永遠無法開立“盈利”存款，則輸出 0。
示例
輸入
5
10 5
7 9
5 100
1 1
1 2
輸出
10
5
0
1
0
注意
在第一個測試案例中，\(a \geq b\)，因此 Alice 可以立即用所有 10 個硬幣開立“盈利”存款。
在第二個測試案例中，Alice 可以用 2 個硬幣開立“無盈利”存款。然後她將剩下 5 個硬幣，但開立“盈利”存款所需的最低金額將減少 4 個硬幣，使其等於 5 個硬幣。因此，Alice 將能夠用 5 個硬幣開立“盈利”存款。
在第三個測試案例中，Alice 將無法開立“盈利”存款。
解題思路
根據題目要求列出公式\(a-x=b-2x\)，移項得\(x=b-a\)。再特判一下極端情況即可。
程式碼實現
void solve()
{
ll a, b;
cin >> a >> b;
if (a >= b)
{
cout << a << endl;
return;
}
else if (a * 2 <= b)
{
cout << 0 << endl;
return;
}
int d = b - a;
cout << a - d << endl;
}
B. Buying Lemonade
每個測試的時間限制：1秒
每個測試的記憶體限制：256兆位元組
輸入：標準輸入
輸出：標準輸出
有一臺出售檸檬水的自動售貨機。這臺機器共有 \(n\) 個槽位。你知道最初，第 \(i\) 個槽位包含 \(a_i\) 罐檸檬水。機器上還有 \(n\) 個按鈕，每個按鈕對應一個槽位，每個槽位對應一個按鈕。不幸的是，按鈕上的標籤已經磨損，所以你不知道哪個按鈕對應哪個槽位。
當你按下與第 \(i\) 個槽位對應的按鈕時，會發生以下兩種情況之一：
- 如果第 \(i\) 個槽位中有一罐檸檬水，它會掉出來，你會拿走它。此時，第 \(i\) 個槽位中的罐子數量減少了 \(1\)。
- 如果第 \(i\) 個槽位中沒有剩餘的檸檬水罐，則不會掉出任何東西。
按下按鈕後，罐子會快速掉出，因此無法追蹤它從哪個槽位掉落。槽位的內容隱藏在您的視野之外，因此您無法看到每個槽位中剩餘的罐子數量。您唯一知道的是槽位中的初始罐子數量： \(a_1, a_2, \ldots, a_n\)。
確定需要按下的最少按鈕次數，以保證您至少收到 \(k\) 罐檸檬水。
請注意，您可以根據是否收到罐子來調整按鈕按下時的策略。保證機器中總共至少有 \(k\) 罐檸檬水。換句話說， \(k \leq a_1 + a_2 + \ldots + a_n\)。
輸入
每個測試由多個測試用例組成。第一行包含一個整數 \(t\) (\(1 \leq t \leq 10^4\)) — 測試用例的數量。測試用例的描述如下。
每個測試用例的第一行包含兩個整數 \(n\) 和 \(k\) (\(1 \leq n \leq 2 \cdot 10^5, 1 \leq k \leq 10^9\)) — 機器中的插槽數量和所需的檸檬水罐數。
每個測試用例的第二行包含 \(n\) 個整數 \(a_1, a_2, \ldots, a_n\) (\(1 \leq a_i \leq 10^9\)) — 插槽中的罐子數量。
保證有 \(k \leq a_1 + a_2 + \ldots + a_n\) ，這意味著機器中至少有 \(k\) 罐檸檬水。
保證所有測試用例的 \(n\) 之和不超過 \(2 \cdot 10^5\)。
輸出
對於每個測試用例，輸出一個整數 — 保證您收到至少 \(k\) 罐檸檬水所需的最少按鈕按下次數。
示例
輸入
5
2 1
1 1
2 2
1 2
3 4
2 1 3
10 50
1 1 3 8 8 9 12 13 27 27
2 1000000000
1000000000 500000000
輸出
1
2
5
53
1000000000
注意
在第一個測試用例中，我們可以簡單地按下第一個按鈕並收到一罐檸檬水。
在第二個測試用例中，我們可以按下每個按鈕一次，確保我們收到 \(2\) 罐檸檬水。請注意，如果我們只是按下一個按鈕兩次，我們可能不會幸運，那樣的話按鈕可能對應第一個槽位，在這種情況下我們只會收到 \(1\) 罐檸檬水。
在第三個測試用例中，最優策略之一如下：
- 按下第一個按鈕兩次。第一次按下後，肯定會掉出一罐檸檬水。然後有兩種選擇：
- 如果第二次按下後沒有掉出檸檬水，我們知道這個按鈕一定對應第二個槽位，因為 \(a_2=1\) 且 \(a_1, a_3 > 1\)。然後我們可以按下第二個按鈕兩次，第三個按鈕一次。由於 \(a_1, a_3 \geq 2\)，我們肯定會在這三次按下中收到三罐檸檬水。因此，在 \(5\) 次按下後，我們將獲得 \(4\) 罐檸檬水。
- 如果第二次按下後掉出了一罐檸檬水，我們可以按下第二個按鈕一次，第三個按鈕一次。在每次按下中，我們肯定會收到一罐檸檬水。因此，在 \(4\) 次按下後，我們將獲得 \(4\) 罐檸檬水。
可以證明，僅用 \(4\) 次按下是無法保證收到 \(4\) 罐檸檬水的，因此答案是 \(5\)。
解題思路
對於任意一個按鈕，如果我們按下之後它不再出水，那我們肯定不會再去按它。為了讓我們按按鈕的總次數儘量少，我們需要不去按下已經不出水的按鈕。
一個顯然的策略是一輪按下所有還出水的按鈕即\(a_i\gt now\)，\(now\)為已經按下的次數。
為了方便維護\(a_i>now\)，我們可以將\(a\)升序排序，如果\(a_i\le now\)，我們可以把\(i\)往後挪直達\(a_j>now\)
觀察到\(a_i\le10^9\)，不能一輪一輪模擬，需要使用除法加速。
程式碼實現
void solve()
{
ll n, k;
cin >> n >> k;
vl a(n);
for (int i = 0; i < n; i++)
{
cin >> a[i];
}
sort(all(a)); // 將罐子數量排序
ll len = n; // 剩餘槽位數量
ll ans = 0; // 按鈕按下的總次數
ll now = 0; // 當前獲得的檸檬水數量
int i = 0; // 當前槽位索引
while (k)
{
// 處理當前槽位
while (a[i] <= now) // 如果當前槽位的罐子數量小於等於已獲得的數量
{
i++;
ans++; // 按下按鈕
len--; // 剩餘槽位數量減少
}
// 計算當前槽位能提供的檸檬水
if (k >= len) // 如果我們需要的數量大於或等於剩餘槽位數量
{
ll t = k / len; // 每個槽位至少要按下 t 次
ll cnt = min(t, a[i] - now); // 當前槽位能提供的數量
ans += cnt * len; // 計算總的按鈕按下次數
now += cnt; // 更新已獲得的數量
k -= cnt * len; // 更新還需的數量
}
else // 如果需要的數量小於剩餘槽位數量
{
ans += k; // 直接按下 k 次
k = 0; // 更新還需的數量
}
}
cout << ans << endl; // 輸出結果
}
C. Concatenation of Arrays
時間限制：每個測試 2 秒
記憶體限制：每個測試 256 兆位元組
輸入：標準輸入
輸出：標準輸出
給定 \(n\) 個陣列 \(a_1, \ldots, a_n\)。每個陣列的長度為 \(2\)，因此 \(a_i = [a_{i,1}, a_{i,2}]\)。您需要將這些陣列連線成一個長度為 \(2n\) 的陣列，以使結果陣列中的逆序對數量最小化。請注意，您不需要計算實際的逆序對數量。
更正式地說，您需要選擇一個長度為 \(n\) 的排列 \(p\)，以便陣列 \(b = [a_{p_1,1}, a_{p_1,2}, a_{p_2,1}, a_{p_2,2}, \ldots, a_{p_n,1}, a_{p_n,2}]\) 包含儘可能少的逆序對。
逆序對的定義是：陣列 \(c\) 中的逆序對數量是索引對 \(i\) 和 \(j\) 的數量，使得 \(i < j\) 且 \(c_i > c_j\)。
一個長度為 \(n\) 的排列是一個由 \(n\) 個不同整陣列成的陣列，這些整數從 \(1\) 到 \(n\) 以任意順序排列。例如， \([2,3,1,5,4]\) 是一個排列，但 \([1,2,2]\) 不是一個排列（\(2\) 在陣列中出現了兩次）， \([1,3,4]\) 也不是排列（\(n=3\) 但是陣列中有 \(4\)）。
輸入
每個測試由多個測試用例組成。第一行包含一個整數 \(t\) (\(1 \leq t \leq 10^4\)) — 測試用例的數量。測試用例的描述如下。
每個測試用例的第一行包含一個整數 \(n\) (\(1 \leq n \leq 10^5\)) — 陣列的數量。
接下來的每一行包含兩個整數 \(a_{i,1}\) 和 \(a_{i,2}\) (\(1 \leq a_{i,j} \leq 10^9\)) — 第 \(i\) 個陣列的元素。
保證所有測試用例的 \(n\) 的總和不超過 \(10^5\)。
輸出
對於每個測試用例，輸出 \(2n\) 個整數 — 您獲得的陣列的元素。如果有多個解決方案，則輸出其中任何一個。
示例
輸入
4
2
1 4
2 3
3
3 2
4 3
2 1
5
5 10
2 3
9 6
4 1
8 7
1
10 20
輸出
2 3 1 4
2 1 3 2 4 3
4 1 2 3 5 10 8 7 9 6
10 20
注意
在第一個測試用例中，我們以順序 \(2, 1\) 連線陣列。考慮結果陣列 \(b = [2, 3, 1, 4]\) 中的逆序對：
- \(i=1, j=3\)，因為 \(b_1=2 > 1=b_3\)；
- \(i=2, j=3\)，因為 \(b_2=3 > 1=b_3\)。
因此，逆序對的數量是 \(2\)。可以證明這是可能的最小逆序對數量量。
在第二個測試用例中，我們以順序 \(3, 1, 2\) 連線陣列。考慮結果陣列 \(b = [2, 1, 3, 2, 4, 3]\) 中的逆序對：
- \(i=1, j=2\)，因為 \(b_1=2 > 1=b_2\)；
- \(i=3, j=4\)，因為 \(b_3=3 > 2=b_4\)；
- \(i=5, j=6\)，因為 \(b_5=4 > 3=b_6\)。
因此，逆序對的數量是 \(3\)。可以證明這是可能的最小逆序對數量量。
在第三個測試用例中，我們以順序 \(4, 2, 1, 5, 3\) 連線陣列。
解題思路
為了確保連線後的陣列儘可能減少逆序對數量，我們按以下規則進行排序。
-
最小值優先：首先根據每個陣列的最小值進行排序，可以確保在連線陣列時，較小的元素會出現在前面，從而減少後面元素大於前面元素的情況。
-
最大值次之：如果兩個陣列的最小值相同，則根據最大值進行排序。這是為了在最小值相同的情況下，進一步控制元素的相對順序，確保較大的元素不會在較小元素之前出現。
考慮兩個陣列 $ a = [x_1, y_1] $ 和 $ b = [x_2, y_2] $，其中 $ x_1 \leq y_1 $ 和 $ x_2 \leq y_2 $。
- 排序依據：
- 如果 $ x_1 < x_2 $，那麼在連線時 $ x_1 $ 會在 $ x_2 $ 之前，減少逆序對。
- 如果 $ x_1 = x_2 $，那麼需要看 $ y_1 $ 和 $ y_2 $ 的大小：
- 如果 $ y_1 < y_2 $，那麼連線後 $ y_1 $ 會在 $ y_2 $ 之前，繼續減少逆序對。
- 如果 $ y_1 \geq y_2 $，則可能會增加逆序對，但由於最小值相同，造成的影響相對較小。
假設我們有以下陣列：
- $ a_1 = [1, 4] $
- $ a_2 = [2, 3] $
如果我們不進行排序，直接連線可能得到 $ [1, 4, 2, 3] $，這裡會有逆序對（例如 $ 4 > 2 $ 和 $ 4 > 3 $），逆序對數量較多。
如果我們按照最小值排序，得到的順序是 $ a_2, a_1 $，連線後得到 $ [2, 3, 1, 4] $，這樣逆序對數量明顯減少。
程式碼實現
void solve()
{
int n;
cin >> n;
vpii a(n);
for (int i = 0; i < n; ++i)
{
cin >> a[i].ft >> a[i].sd;
}
sort(all(a), [&](const pii &x, const pii &y)
{
if(min(x.ft, x.sd) != min(y.ft, y.sd))
return min(x.ft, x.sd) < min(y.ft, y.sd);
return max(x.ft, x.sd) < max(y.ft, y.sd); });
for (int i = 0; i < n; ++i)
{
cout << a[i].ft << " " << a[i].sd << " \n"[i == n - 1];
}
}
D. Skipping
時間限制：每個測試 2 秒
記憶體限制：每個測試 256 兆位元組
輸入：標準輸入
輸出：標準輸出
現在已經是3024年，題目的想法早已用盡，奧林匹克競賽現在以經過修改的個人形式舉行。奧林匹克競賽由 \(n\) 個問題組成，編號從 \(1\) 到 \(n\)。第 \(i\) 個問題有自己的分數 \(a_i\) 和特定引數 \(b_i\) (\(1 \leq b_i \leq n\))。
最初，測試系統會給參與者第一個問題。當參與者得到第 \(i\) 個問題時，他們有兩個選擇：
- 提交問題並獲得 \(a_i\) 分；
- 跳過這個問題，在這種情況下他們將永遠無法提交它。
然後，測試系統從索引為 \(j\) 的問題中為參與者選擇下一個問題：
- 如果他提交了第 \(i\) 個問題，則檢視索引為 \(j < i\) 的問題；
- 如果他跳過了第 \(i\) 個問題，則檢視索引為 \(j \leq b_i\) 的問題。
在這些問題中，它選擇索引為最大的問題，該問題以前沒有給過參與者（他以前既沒有提交過也沒有跳過過）。如果沒有這樣的問題，則參與者的比賽結束，他們的結果等於所有提交問題的分數總和。特別是，如果參與者提交了第一個問題，則他們的比賽結束。請注意，參與者最多收到每個問題一次。
Prokhor 已經為奧林匹克競賽做好了充分的準備，現在他可以提交任何問題。幫助他確定他可以獲得的最高分數。
輸入
每個測試由多個測試用例組成。第一行包含一個整數 \(t\) (\(1 \leq t \leq 10^5\)) — 測試用例的數量。測試用例的描述如下。
每個測試用例的第一行包含一個整數 \(n\) (\(1 \leq n \leq 4 \cdot 10^5\)) — 奧林匹克競賽中的問題數量。
第二行包含 \(n\) 個整數 \(a_1, a_2, \ldots, a_n\) (\(1 \leq a_i \leq 10^9\)) — 問題的分數。
第三行包含 \(n\) 個整數 \(b_1, b_2, \ldots, b_n\) (\(1 \leq b_i \leq n\)) — 問題的引數。
保證所有測試用例的 \(n\) 的總和不超過 \(4 \cdot 10^5\)。
輸出
對於每個測試用例，輸出一個整數——Prokhor 可以獲得的最大分數。
示例
輸入
4
2
15 16
2 1
5
10 10 100 100 1000
3 4 1 1 1
3
100 49 50
3 2 2
4
100 200 300 1000
2 3 4 1
輸出
16
200
100
1000
注意
在第一個測試用例中，Prokhor 可以跳過第一個問題；然後他將收到索引為 \(b_1=2\) 的問題。Prokhor 可以提交它並獲得 \(a_2=16\) 分。之後，比賽將結束，因為 Prokhor 已經收到所有問題。請注意，如果 Prokhor 提交第一個問題，他將獲得 \(a_1=15\) 分，但比賽會立即結束。
在第二個測試用例中，Prokhor 可以跳過第一個問題；然後他將收到索引為 \(b_1=3\) 的問題。Prokhor 可以提交它並獲得 \(a_3=100\) 分。之後，Prokhor 將收到第二個問題，他可以跳過以接收索引為 \(b_2=4\) 的問題。Prokhor 可以提交第四個問題並獲得另一個 \(a_4=100\) 分。之後，比賽結束，因為 Prokhor 已經收到所有索引不超過 \(4\) 的問題。因此，Prokhor 將獲得總共 \(200\) 分。
在第三個測試用例中，Prokhor 可以提交第一個問題並獲得 \(100\) 分，之後比賽會立即結束。
解題思路
觀察題目發現，我們最優的策略一定是經過一系列點\(p_1,p_2,p_3\dots p_m\)到達\(p_m\)後停下，然後在\(p_m\)跳轉到所有\(i\notin P,i<p_m\)的點上獲取它們的分數，且\(\forall i\lt m,p_i\lt p_m\)。如果\(\exist p_j\gt p_m\)那我們在\(p_j\)停下一定不劣於在\(p_m\)停下。
答案\(\text{ans}=\text{min}( \text{prefix}_{p_m}-\sum^{m}_{i=1}a_{p_i}),1\le p_m\le n\)
所以我們可以建圖，然後跑最短路，算出到達每一個點的最小花費。
對於第一種操作，對\(i\rightarrow i-1\)建邊，其邊權為\(0\)
對於第二種操作，對\(i\rightarrow b_i\)建邊，其邊權為\(a_i\)
然後跑一遍dijkstra算出到達每一個點的最小代價
然後列舉所有可能的終點即可。
這題還有dp的做法，我有空補補。
程式碼實現
void solve()
{
int n;
cin >> n;
vi a(n + 1);
vl pre(n + 1);
for (int i = 1; i <= n; i++)
{
cin >> a[i];
pre[i] = pre[i - 1] + a[i];
}
vi b(n + 1);
for (int i = 1; i <= n; i++)
{
cin >> b[i];
}
vvi adj(n + 1);
vvl w(n + 1);
for (int i = 1; i <= n; i++)
{
adj[i].pb(b[i]);
w[i].pb(a[i]);
if (i != 1)
{
adj[i].pb(i - 1);
w[i].pb(0);
}
}
vl dis(n + 1, infll);
vb vis(n + 1);
dis[1] = 0;
auto dijkstra = [&]()
{
priority_queue<pll, vpll, greater<pll>> q;
q.push({0, 1});
while (!q.empty())
{
auto t = q.top();
q.pop();
ll d = t.ft;
int u = t.sd;
if (vis[u])
continue;
vis[u] = true;
for (int i = 0; i < adj[u].size(); i++)
{
int v = adj[u][i];
ll cost = d + w[u][i];
if (dis[v] > cost)
{
dis[v] = cost;
q.push({cost, v});
}
}
}
};
dijkstra();
ll ans = 0;
for (int i = 1; i <= n; i++)
{
ans = max(ans, pre[i] - dis[i]);
}
cout << ans << endl;
}
E不會寫，看不懂一點，最近這幾場掉大分，本來差12分上紫，結果狂掉270分，差點掉出藍了，場場卡B和C,導致沒時間寫後面的了，人快麻了。