文章目錄

• A - 2nd Greatest Distance
• B - RGB Matching
• C - Odd Even Sort
• D - 1 or 2
• E - Directed Tree
• F - Logical Operations on Tree

NOMURA Programming Contest 2021(AtCoder Regular Contest 121)

A - 2nd Greatest Distance

大模擬討論yyds

將點按$x,y$分別排序

• $x$貢獻最大值的點對等于$y$貢獻最大值的點對

  次小值就變成$x/y$中最大次小和次大最小一共四種組合中的最大值

• $x$最大最小貢獻點對不等于$y$最大最小點對

  • $x$最大最小更大

    $y$最大最小與$x$中次大最小和最大次小比較

  • $y$最大最小更大

    $x$最大最小與$y$中次大最小和最大次小比較

#include <cstdio> #include <iostream> #include <algorithm> using namespace std; #define int long long #define maxn 200005 struct node {int x, y, id; }h1[maxn], h2[maxn]; int n;bool cmp1( node s, node t ) {return s.x < t.x; }bool cmp2( node s, node t ) {return s.y < t.y; }signed main() {scanf( "%lld", &n );for( int i = 1;i <= n;i ++ ) {scanf( "%lld %lld", &h1[i].x, &h1[i].y );h1[i].id = i;h2[i] = h1[i];}sort( h1 + 1, h1 + n + 1, cmp1 );sort( h2 + 1, h2 + n + 1, cmp2 );if( ( h1[1].id == h2[1].id && h1[n].id == h2[n].id ) || ( h1[1].id == h2[n].id && h1[n].id == h2[1].id ) )printf( "%lld\n", max( max( h1[n].x - h1[2].x, h1[n - 1].x - h1[1].x ), max( h2[n].y - h2[2].y, h2[n - 1].y - h2[1].y ) ) );else if( h1[n].x - h1[1].x < h2[n].y - h2[1].y )printf( "%lld\n", max( h1[n].x - h1[1].x, max( h2[n].y - h2[2].y, h2[n - 1].y - h2[1].y ) ) );elseprintf( "%lld\n", max( h2[n].y - h2[1].y, max( h1[n].x - h1[2].x, h1[n - 1].x - h1[1].x ) ) );return 0; }

B - RGB Matching

顯然，最后要么三種顏色的狗全是偶數條，兩兩配對，答案為$0$；要么只會恰有兩種顏色的狗為奇數條

case 1

兩種顏色中選擇不滿意值相差最小的兩條狗

具體來說，枚舉一種顏色的狗，再二分左右求出與該狗不滿意值差距最小的狗，整體不滿意值取最小值

case 2

第三顏色狗起一個中轉點的作用

具體來說，分別枚舉兩種顏色的狗，以及在第三顏色中求出與枚舉狗不滿意值差距最小的狗

整體取不滿意值最小，兩種顏色最小再相加

#include <cstdio> #include <vector> #include <algorithm> using namespace std; #define int long long vector < int > G[3]; int n, pos_l, pos_r;int id( char ch ) {if( ch == 'R' ) return 0;if( ch == 'B' ) return 1;if( ch == 'G' ) return 2; }int Fabs( int x ) {return x < 0 ? -x : x; }void work( int c, int val ) {int l = 0, r = G[c].size() - 1;pos_l = 0, pos_r = G[c].size() - 1;while( l <= r ) {int mid = ( l + r ) >> 1;if( G[c][mid] <= val ) pos_l = mid, l = mid + 1;else r = mid - 1;}l = 0, r = G[c].size() - 1;while( l <= r ) {int mid = ( l + r ) >> 1;if( G[c][mid] >= val ) pos_r = mid, r = mid - 1;else l = mid + 1;} }signed main() {scanf( "%lld", &n );for( int i = 1;i <= ( n << 1 );i ++ ) {char c; int a;scanf( "%lld %c", &a, &c );G[id( c )].push_back( a );}int c1 = -1, c2 = -1;for( int i = 0;i < 3;i ++ )if( G[i].size() & 1 ) {if( ~ c1 ) c2 = i;else c1 = i;}if( c1 == -1 ) return ! printf( "0\n" );else {int ans = 1e18;sort( G[c2].begin(), G[c2].end() );for( int i = 0;i < G[c1].size();i ++ ) {work( c2, G[c1][i] );ans = min( ans, min( Fabs( G[c1][i] - G[c2][pos_l] ), Fabs( G[c2][pos_r] - G[c1][i] ) ) );}int ans1 = 1e18, ans2 = 1e18, c;for( int i = 0;i < 3;i ++ )if( c1 == i || c2 == i ) continue;else c = i;if( ! G[c].size() ) goto pass;sort( G[c].begin(), G[c].end() );for( int i = 0;i < G[c1].size();i ++ ) {work( c, G[c1][i] );ans1 = min( ans1, min( Fabs( G[c1][i] - G[c][pos_l] ), Fabs( G[c][pos_r] - G[c1][i] ) ) );}for( int i = 0;i < G[c2].size();i ++ ) {work( c, G[c2][i] );ans2 = min( ans2, min( Fabs( G[c2][i] - G[c][pos_l] ), Fabs( G[c][pos_r] - G[c2][i] ) ) );}pass : printf( "%lld\n", min( ans, ans1 + ans2 ) );}return 0; }

C - Odd Even Sort

題讀錯做法千奇百怪錯 奇數次操作只能操作奇數位置，偶數次操作只能操作偶數位置

問題不要求操作最小，只求不超過$n^2$（冒泡排序復雜度），想法一下子就來了，明顯的構造

從最大值往最小值依次考慮($k$)，也就是只用考慮右移的操作

不難發現，如果$k$本身處于位置與操作次數恰好同奇偶，那么可以直接一直操作$k$直到位置$k$

如果不同奇偶，那么就像能否先操作一次無關的位置，再一直操作$k$

這顯然是可以的，每次奇偶就讓$1,2$位置與后面一個進行交換

當然還有位置與值已經匹配的，直接下一個哈

#include <cstdio> #include <iostream> #include <algorithm> using namespace std; #define maxn 505 int T, n; int a[maxn], b[maxn], ans[maxn * maxn];int main() {scanf( "%d", &T );while( T -- ) {scanf( "%d", &n );for( int i = 1;i <= n;i ++ )scanf( "%d", &a[i] ), b[i] = a[i];sort( b + 1, b + n + 1 );int cnt = 0, ip = n;for( int t = 1;t <= n * n && ip;t ++ ) {bool flag = 0;for( int i = 1;i < n;i ++ )if( a[i] > a[i + 1] ) {flag = 1;break;}if( ! flag ) break;int pos;for( int i = 1;i <= n;i ++ )if( a[i] == b[ip] ) {pos = i;break;}if( ( pos & 1 ) == ( t & 1 ) ) {while( pos < ip ) {ans[++ cnt] = pos;t ++;swap( a[pos], a[pos + 1] );pos ++;}t --;ip --;}else {flag = 1;for( int i = ( ( t & 1 ) ? 1 : 2 );i < n;i += 2 )if( a[i] > a[i + 1] ) {ans[++ cnt] = i;swap( a[i], a[i + 1] );flag = 0;break;}if( flag ) {int x = ( ( t & 1 ) ? 1 : 2 );ans[++ cnt] = x;swap( a[x], a[x + 1] );}}}printf( "%d\n", cnt );if( cnt ) {for( int i = 1;i <= cnt;i ++ )printf( "%d ", ans[i] );printf( "\n" );}}return 0; }

D - 1 or 2

肯定是最大最小，次大次小…一一配對

$a<b<c<d?max(a+d,b+c)\le max(a+c,b+d);min(a+c,b+d)\le min(a+d,b+c)$

如果是一個蛋糕，不妨看做和$0$合并，所以只需要枚舉$0$的個數排序順次合并即可，$O(n^2)$

#include <cstdio> #include <vector> #include <iostream> #include <algorithm> using namespace std; #define maxn 5005 #define int long long vector < int > g; int n;signed main() {scanf( "%lld", &n );for( int i = 1, x;i <= n;i ++ ) {scanf( "%lld", &x );g.push_back( x );}sort( g.begin(), g.end() );int Size = g.size(), maxx = -1e18, minn = 1e18;for( int i = 0;i < ( Size >> 1 );i ++ ) {maxx = max( g[Size - 1 - i] + g[i], maxx );minn = min( g[Size - 1 - i] + g[i], minn );}if( Size & 1 ) {maxx = max( g[Size >> 1], maxx );minn = min( g[Size >> 1], minn );}int ans = maxx - minn;for( int i = 1;i <= n;i ++ ) {g.push_back( 0 ), Size ++;for( int i = Size - 1;i;i -- )if( g[i] < g[i - 1] ) swap( g[i], g[i - 1] );else break;maxx = -1e18, minn = 1e18;for( int i = 0;i < ( Size >> 1 );i ++ ) {maxx = max( g[Size - 1 - i] + g[i], maxx );minn = min( g[Size - 1 - i] + g[i], minn );}if( Size & 1 ) {maxx = max( g[Size >> 1], maxx );minn = min( g[Size >> 1], minn );}ans = min( ans, maxx - minn );}printf( "%lld\n", ans );return 0; }

E - Directed Tree

套路都見過，卻沒有反應過來

設$d{p}_{i,j}:i$ 子樹內不滿足條件的節點數為$j$

$d{p}_{u,j+k}={\sum }_{j=0}^{siz{e}_u}{\sum }_{k=0}^{siz{e}_v}d{p}_{u,j}\times d{p}_{v,k}$

最后容斥

$ans={\sum }_{i=0}^n(?1{)}^{i}d{p}_{1,i}\times (n?i)!$

#include <cstdio> #include <vector> using namespace std; #define int long long #define mod 998244353 #define maxn 2005 vector < int > G[maxn]; int n; int fac[maxn], siz[maxn], g[maxn]; int dp[maxn][maxn];void dfs( int u ) {dp[u][0] = 1;for( int i = 0;i < G[u].size();i ++ ) {int v = G[u][i];dfs( v );for( int j = 0;j <= siz[u];j ++ )for( int k = 0;k <= siz[v];k ++ )g[j + k] = ( g[j + k] + dp[u][j] * dp[v][k] % mod ) % mod;siz[u] += siz[v];for( int j = 0;j <= siz[u];j ++ )dp[u][j] = g[j], g[j] = 0;}for( int i = siz[u];~ i;i -- )dp[u][i + 1] = ( dp[u][i + 1] + dp[u][i] * ( siz[u] - i ) % mod ) % mod;siz[u] ++; }signed main() {scanf( "%lld", &n );for( int i = 2, p;i <= n;i ++ ) {scanf( "%lld", &p );G[p].push_back( i );}dfs( 1 );fac[0] = 1;for( int i = 1;i <= n;i ++ )fac[i] = fac[i - 1] * i % mod;int ans = 0;for( int i = 0;i <= n;i ++ )if( i & 1 ) ans = ( ans - dp[1][i] * fac[n - i] % mod + mod ) % mod;else ans = ( ans + dp[1][i] * fac[n - i] % mod ) % mod;printf( "%lld\n", ans );return 0; }

F - Logical Operations on Tree

$N=1$結果顯然，考慮其他情況

如果一個葉子標記為1并且與之相連的邊是OR

不管其它長什么樣都可以將這條邊的操作放在最后一步，從而符合要求，簡稱好樹

接下來考慮沒有這種葉子，合并出新點的情況

• 如果葉子u的標記為0，且相連邊是AND，則這條邊操作后，新點一定標記為0

  如果執行這條邊后的樹是好樹，那么原來的樹也一定是好樹

• 如果葉子u的標記為0，且相連邊是OR，則這條邊操作后，原來與葉子相連點的標記即為新點標記

  如果執行這條邊后的樹是好樹，那么原來的樹也一定是好樹

• 如果葉子u的標記為1，且相連邊是AND，則這條邊操作后，原來與葉子相連點的標記即為新點標記

  如果執行這條邊后的樹是好樹，那么原來的樹也一定是好樹

在樹上從葉子到父親搭建，出現1 OR時剩下的點邊不管是什么，一定也是好樹了；否則把葉子扔掉，父親節點可能為0/1，在樹上$DP$

$f:$ 子樹內沒有出現1 OR想要邊的樹個數，$g: $ 在$f$所有方案數中好樹的個數

ps：沒有出現1 OR這種關鍵葉子標記1指向父親種類，但是可以出現1 OR父親標記1的情況，因為可能父親的其它兒子操作時會導致父親標記變化

#include <cstdio> #include <vector> using namespace std; #define int long long #define mod 998244353 #define maxn 100005 vector < int > G[maxn]; int n; int f[maxn], g[maxn];int qkpow( int x, int y ) {int ans = 1;while( y ) {if( y & 1 ) ans = ans * x % mod;x = x * x % mod;y >>= 1;}return ans; }void dfs( int u, int fa ) {f[u] = 2, g[u] = 1;for( int i = 0;i < G[u].size();i ++ ) {int v = G[u][i];if( v == fa ) continue;else dfs( v, u );f[u] = ( ( f[v] * 2 - g[v] ) * f[u] % mod + mod ) % mod;g[u] = g[u] * f[v] % mod;} }signed main() {scanf( "%lld", &n );for( int i = 1, u, v;i < n;i ++ ) {scanf( "%lld %lld", &u, &v );G[u].push_back( v );G[v].push_back( u );}dfs( 1, 0 );printf( "%lld\n", ( qkpow( 2, n * 2 - 1 ) - f[1] + g[1] + mod ) % mod );return 0; }

總結

以上是生活随笔為你收集整理的NOMURA Programming Contest 2021(AtCoder Regular Contest 121)的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。