ABC335 A-E 题解

2023

给你一个字符串 \(s\)，把 \(s\) 的最后一个改成 \(4\) 之后输出就行了。用 python 代码更短哦

#include <iostream>

using namespace std;

int main() {
  string s;
  cin >> s;
  cout << s.substr(0, s.size() - 1) + "4" << '\n';
}

print(input()[:-1] + '4')

Tetrahedral Number

给你一个整数 \(n\)，要你按照字典序找到所有的三元组 \((i,j,k)\) \((0\le i,j,k)\)，使得 \(i+j+k\le n\)。直接暴力三重循环或者使用 dfs，但是我就是喜欢暴力循环，因为代码更短。

#include <iostream>

using namespace std;

int n;

int main() {
  cin >> n;
  for (int i = 0; i <= n; i++) {
    for (int j = 0; i + j <= n; j++) {
      for (int k = 0; i + j + k <= n; k++) {
        cout << i << ' ' << j << ' ' << k << '\n';
      }
    }
  }
  return 0;
}

import java.util.*;

public class Main {
  public final static Scanner cin = new Scanner(System.in);
  public static int n = cin.nextInt();

  public static void main(String[] args) {
    for (int i = 0; i <= n; i++) {
      for (int j = 0; i + j <= n; j++) {
        for (int k = 0; i + j + k <= n; k++) {
          System.out.println(i + " " + j + " " + k);
        }
      }
    }
  }
}

n = int(input())
for i in range(0, n + 1):
  for j in range(0, n - i + 1):
    for k in range(0, n - i - j + 1):
      print(f'{i} {j} {k}')

Loong Tracking

有一个长度为 \(N\) 的龙，最开始第 \(i\) 部分的位置在 \((i,0)\) 上面。接下来有 \(Q\) 个询问，每一个询问都有修改或删除。\(\fbox{1 C}\) 表示把头将 \(C\) 的方向移动一格，后面的部分跟上来；\(\fbox{2 p}\) 输出 \(p\) 部分的坐标。

很简单，我们不需要使用复杂的操作，只需要使用 STL 当中的双端队列就行了。首先把 \(N\) 个部分全部加入到队列里面，然后照样子处理询问就行，最后输出的时候由于 Debug 可以通过下标访问，因此直接访问下标就行了。

#include <iostream>
#include <deque>

using namespace std;

int n, q, o, p;
char c;
deque<pair<int, int>> dq;

int main() {
  cin >> n;
  for (int i = 1; i <= n; i++) {
    dq.emplace_back(i, 0);
  }
  for (cin >> q; q; q--) {
    cin >> o;
    if (o == 1) {
      cin >> c;
      c == 'U' ? dq.emplace_front(dq.front().first, dq.front().second + 1) :
      c == 'D' ? dq.emplace_front(dq.front().first, dq.front().second - 1) :
      c == 'L' ? dq.emplace_front(dq.front().first - 1, dq.front().second) :
                 dq.emplace_front(dq.front().first + 1, dq.front().second);
      dq.pop_back();
    } else {
      cin >> p;
      cout << dq[p - 1].first << ' ' << dq[p - 1].second << '\n';
    }
  }
  return 0;
}

[ABC335D] Loong and Takahashi

题面描述

给定一个 \(N \times N\) 的网格，其中 \(N\) 是小于等于 \(45\) 的奇数。
龙和高桥君要在这个网格上放置 \(N^2-1\) 个编号从 \(1\) 到 \(N^2-1\) 的龙的部件，满足以下条件：

• 高桥君必须放置在网格的中心位置，即 \((\frac{N+1}{2},\frac{N+1}{2})\)。
• 除了高桥君所在的位置外，每个格子必须恰好放置一个龙的部件。
• 对于满足 \(2 \leq x \leq N^2-1\) 的所有整数 \(x\)，龙的部件 \(x\) 必须放置在与部件 \(x-1\) 相邻的格子上，即两个格子之间有边相连。
  • 格子 \((i,j)\) 与格子 \((k,l)\) 相邻，当且仅当 \(|i-k|+|j-l|=1\)。

请输出满足条件的一种放置方式。

思路

很简单，循环或者递归直接秒了。

#include <iostream>

using namespace std;

const int kMaxN = 1005, kD[4][2] = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};

int a[kMaxN][kMaxN], n;

void dfs(int x, int y, int k, int t) {
  a[x][y] = k;
  if (!a[x + kD[t][0]][y + kD[t][1]]) {
    dfs(x + kD[t][0], y + kD[t][1], k + 1, t);
  } else if (!a[x + kD[(t + 1) % 4][0]][y + kD[(t + 1) % 4][1]]) {
    dfs(x + kD[(t + 1) % 4][0], y + kD[(t + 1) % 4][1], k + 1, (t + 1) % 4);
  }
}

int main() {
  cin >> n;
  for (int i = 0; i <= n + 1; i++) {
    a[0][i] = a[i][0] = a[n + 1][i] = a[i][n + 1] = 1;
  }
  dfs(1, 1, 1, 0);
  for (int i = 1; i <= n; i++) {
    for (int j = 1; j <= n; j++) {
      if (i == n / 2 + 1 && j == n / 2 + 1) {
        cout << "T ";
      } else {
        cout << a[i][j] << ' ';
      }
    }
    cout << '\n';
  }
  return 0;
}

Non-Decreasing Colorful Path

题目描述

给定一个有 \(N\) 个点 \(M\) 条边的无向图，每一个点上面都有颜色。现在要你找出一条 \(1\sim n\) 的最长路径，使得路径上面的所有经过的点的颜色单调不降。如果没有，输出 \(0\)。

思路

首先，我们可以想到 dp。只要我们根据每一个点的颜色从小到大排序一遍，那么当前颜色只会由比当前颜色小的点给转移过来，而我们排了序，因此调用的子问题就一定是求解过的了。

但是，交上去我们就会发现会 WA 掉，究极原因就是因为有可能有多个同样颜色的点在一起，但是我们不知道他们之间的顺序，因此调用的子问题不一定是已经求解过的，那么就会错掉。所以我们考虑缩点。用并查集存储颜色相同的联通块，然后重新建图就行了。

#include <iostream>
#include <algorithm>
#include <numeric>
#include <vector>

using namespace std;

const int kMaxN = 2e5 + 5;

int b[kMaxN], f[kMaxN], a[kMaxN], dp[kMaxN], u[kMaxN], v[kMaxN], n, m;
vector<int> e[kMaxN];

int F(int x) {
  return f[x] == x ? x : f[x] = F(f[x]);
}

void U(int u, int v) {
  u = F(u), v = F(v);
  u != v && (f[u] = v);
}

int main() {
  cin >> n >> m;
  iota(f + 1, f + n + 1, 1);
  for (int i = 1; i <= n; i++) {
    cin >> a[i], b[i] = i;
  }
  sort(b + 1, b + n + 1, [](const int &x, const int &y) {
    return a[x] < a[y];
  });
  for (int i = 1; i <= m; i++) {
    cin >> u[i] >> v[i];
    a[u[i]] == a[v[i]] && (U(u[i], v[i]), 0);
  }
  for (int i = 1; i <= m; i++) {
    e[F(u[i])].push_back(F(v[i]));
    e[F(v[i])].push_back(F(u[i]));
  }
  fill(dp + 1, dp + n + 1, -1e9);
  dp[F(1)] = 1;
  for (int i = 1; i <= n; i++) {
    for (int j : e[b[i]]) {
      a[j] <= a[b[i]] && (dp[b[i]] = max(dp[b[i]], dp[j] + (a[j] < a[b[i]])));
    }
  }
  cout << (dp[F(n)] < 0 ? 0 : dp[F(n)]) << '\n';
}