Codeforces Round #354 (Div. 2)

5/5

水了场CF，写个水水地题解~~

 

题A CodeForces 676A

题意：给你一个排列，问你交换一次，最大最小位置最远是多少？

题解：暴力交换，暴力算，反正数据小.偷懒被hack更惨！！

 

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

#define lson l, m, rt*2
#define rson m + 1, r, rt*2+1
#define xx first
#define yy second

typedef pair<int,int> pii;
typedef long long ll;
typedef unsigned long long ull;

int s[110], n;

int cal() {
  int p1, m1 = 110, p2, m2 = -110;
  for (int i = 1; i <= n; i++) {
    if (m1 > s[i]) m1 = s[i], p1 = i;
    if (m2 < s[i]) m2 = s[i], p2 = i;
  }
  int ret = abs(p1 - p2);
  return ret;
}

int main() {
//  freopen("case.in", "r", stdin);
  cin >> n;
  for (int i = 1; i <= n; i++) cin >> s[i];
  int ans = 0;
  for (int i = 1; i <= n; i++)
    for (int j = i + 1; j <= n; j++) {
      swap(s[i], s[j]);
      ans = max(ans, cal());
      swap(s[i], s[j]);
    }
  printf("%d
", ans);
  return 0;
}

 

题B CodeForces 676B

题意：给你n层杯子叠起来，然后往上面开始倒水，1s满一个杯子，问你最后又多少个杯子是满的？

题解：数据小，直接模拟，写个dfs即可。

 

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

#define lson l, m, rt*2
#define rson m + 1, r, rt*2+1
#define xx first
#define yy second

typedef pair<int,int> pii;
typedef long long ll;
typedef unsigned long long ull;

int n, t;
int v[110][2];
double cnt[1100];

void init() {
  int cur = 1;
  for (int i = 1; i < 11; i++) {
    for (int j = 0; j < i; j++) {
      v[cur][0] = cur + i;
      v[cur][1] = cur + i + 1;
//      cout << cur << ' ' << v[cur][0] << ' ' << v[cur][1] << endl;
      cur++;
    }
  }
}

void dfs(int d, int cur, double add) {
  cnt[cur] += add;
  if (d >= n) return;
  if (cnt[cur] > 1.0) {
    double flow = cnt[cur] - 1.0;
    cnt[cur] = 1.0;
    dfs(d + 1, v[cur][0], flow / 2);
    dfs(d + 1, v[cur][1], flow / 2);
  }
}

int main() {
//  freopen("case.in", "r", stdin);
  init();
  cin >> n >> t;
  for (int i = 0; i < t; i++) {
    dfs(0, 1, 1.0);
  }
  int ans = 0;
  for (int i = 1; i <= n * (n + 1) / 2; i++) if (cnt[i] >= 1.0) ans++;
  cout << ans << endl;
  return 0;
}

 

题C CodeForces 676C

题意：给你个字符串，只有a和b，然后可以改k个，问你最长连续是多少？

题解：好像可以用单调队列搞，我没想这么多，就用了个二分答案。

 

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

#define lson l, m, rt*2
#define rson m + 1, r, rt*2+1
#define xx first
#define yy second

typedef pair<int,int> pii;
typedef long long ll;
typedef unsigned long long ull;

const int maxn = 1e5 + 100;
char s[maxn];
int n, k, len;
int cnta[maxn], cntb[maxn];

bool check(int m) {
  int best = min(cnta[m - 1], cntb[m - 1]);
  for (int i = 1; i + m <= len; i++) {
    int tmp = min(cnta[i + m - 1] - cnta[i - 1], cntb[i + m - 1] - cntb[i - 1]);
    best = min(best, tmp);
  }
  return best <= k;
}

int main() {
//  freopen("case.in", "r", stdin);
  cin >> n >> k;
  scanf("%s", s);
  len = strlen(s);
  int a = 0, b = 0, L = 0, R = len + 1;
  for (int i = 0; i < len; i++) {
    if (s[i] == 'a') a++; else b++;
    cnta[i] = a; cntb[i] = b;
//    cout << a << ' ' << b << endl;
  }
  while (R - L > 1) {
    int M = (R + L) / 2;
    if (check(M)) L = M;
    else R = M;
  }
  printf("%d
", L);
  return 0;
}

题D CodeForces 676D

题意：给你一个地图，除了‘*’是没有门的其他字符都有相应的门，每次操作可以到对应的门，也可以翻转这个点，然后代价是所有点也同时向顺时针翻转，然后给你起点和终点，问你最小花多少时间。

题解：没看到所有点都翻转，然后码了个最短路，GG。如果所有都可以翻转的话，显然可以用bfs。具体做法是，先用一个can[i][j][k][l]表示当前翻转的面是i面，然后j表示方向，k和l表示位置，先得到第0面，然后可以用一个for循环得到1、2、 3面的情况，然后就是很普通的bfs了。

 

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

#define lson l, m, rt*2
#define rson m + 1, r, rt*2+1
#define xx first
#define yy second

typedef pair<int,int> pii;
typedef long long ll;
typedef unsigned long long ull;

const int maxn = 1e3 + 10, dx[] = {-1, 0, 1, 0}, dy[] = {0, 1, 0, -1};
char maze[maxn][maxn];
int vis[4][maxn][maxn], can[5][5][maxn][maxn];
int n, m, xt, yt, xm, ym;

struct Node {
  int x, y, c, d;
  Node(int x=0, int y=0, int c=0, int d=0) : x(x), y(y), c(c), d(d) {}
};

void init_graph() {
  memset(can, 0, sizeof can);
    for (int i = 0; i < n; i++)
      for (int j = 0; j < m; j++) {
        if(maze[i][j] == '+') can[0][0][i][j] = can[0][1][i][j] = can[0][2][i][j] = can[0][3][i][j] = 1;
        if(maze[i][j] == 'U') can[0][1][i][j] = can[0][2][i][j] = can[0][3][i][j] = 1;
        if(maze[i][j] == 'R') can[0][0][i][j] = can[0][2][i][j] = can[0][3][i][j] = 1;
        if(maze[i][j] == 'D') can[0][0][i][j] = can[0][1][i][j] = can[0][3][i][j] = 1;
        if(maze[i][j] == 'L') can[0][0][i][j] = can[0][1][i][j] = can[0][2][i][j] = 1;
        if(maze[i][j] == '-') can[0][1][i][j] = can[0][3][i][j] = 1;
        if(maze[i][j] == '|') can[0][0][i][j] = can[0][2][i][j] = 1;
        if(maze[i][j] == '^') can[0][0][i][j] = 1;
        if(maze[i][j] == '>') can[0][1][i][j] = 1;
        if(maze[i][j] == 'v') can[0][2][i][j] = 1;
        if(maze[i][j] == '<') can[0][3][i][j] = 1;
      }
    for (int x = 1; x < 4; x++)
      for (int i = 0; i < n; i++)
        for (int j = 0; j < m; j++)
          for (int k = 0; k < 4; k++)
            can[x][(k + 1) % 4][i][j] = can[x - 1][k][i][j];
}

int bfs() {
  queue<Node> q;
  q.push(Node(xt, yt, 0, 0));
  memset(vis, false, sizeof vis);
  vis[0][xt][yt] = 1;
  while (!q.empty()) {
    Node r = q.front(); q.pop();
    if (r.x == xm && r.y == ym) return r.d;

    for (int i = 0; i < 4; i++) if (can[r.c][i][r.x][r.y]) {
      int nx = r.x + dx[i], ny = r.y + dy[i];
      if (nx < 0 || nx >= n || ny < 0 || ny >= m) continue;
      if (vis[r.c][nx][ny] || !can[r.c][(i + 2) % 4][nx][ny]) continue;
      vis[r.c][nx][ny] = 1;
      q.push(Node(nx, ny, r.c, r.d + 1));
    }

    int nc = (r.c + 1) % 4;
    if (vis[nc][r.x][r.y]) continue;
    vis[nc][r.x][r.y] = 1;
    q.push(Node(r.x, r.y, nc, r.d + 1));
  }
  return -1;
}

int main() {
//  freopen("case.in", "r", stdin);
  cin >> n >> m;
  for (int i = 0; i < n; i++) {
    scanf("%s", maze[i]);
  }
  scanf("%d%d%d%d", &xt, &yt, &xm, &ym);
  xt--; yt--; xm--; ym--;
//  cout << xt << ' ' << yt << endl;
  init_graph();
  printf("%d
", bfs());
  return 0;
}

题E CodeForces 676E

题意：给你一个多项式：

P(x) =  anxⁿ  +  an - 1x^n - 1  +  ... +  a1x  +  a0

然后另Q(x) = x - k，两个人轮流填系数使得Q（x）|P（x），也就是存在B(x)使得P(x) = B(x)Q(x)成立，现在可能已经进行了一部分，问你继续玩能不能够获胜？

题解：完全没思路，弃疗了。百度了多项式除法也不会做，然后即参照这位老兄的题解。

主要突破点是找做完除法后的余数，既然是余数，那么P（x）减去余数必然能够被Q（x）整除，那么设这个余数是J，然后满足Q（x）|（P（x）-J），怎么得到这个J呢？从P（x）出发，要每一项都得到一个（x-k）的公因子，那不就可以被Q（x）整除了吗？所以另

J = ankⁿ  +  an - 1k^n - 1  +  ...  +  a1k  +  a0

因为P（x） - J = an（x - k）（...） + an - 1(x - k) (...) + a1(x - k)，所以只要让这个J = 0，就说明可以整除了，之后的情况就像上述博客说的那样了。最后提醒一点是：用这个博客的随机数的方法可以过，将数设为数据没有考虑的一个数也可以过。

 

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

typedef long long ll;
const int maxn = 1e5 + 10, mod = 100003619;
int a[maxn], t[maxn], n, k;
char s[110];

int main() {
//  freopen("case.in", "r", stdin);
  cin >> n >> k;
  int ok = 0, c = 0;
  for (int i = 0; i <= n; i++) {
    scanf("%s", s);
    if (s[0] == '?') ok = 1;
    else {
      t[i] = 1;
      sscanf(s, "%d", a + i);
      c ^= 1;
    }
  }
  if (k == 0) {
    if (t[0]) puts(a[0] == 0 ? "Yes" : "No");
    else puts(c & 1 ? "Yes" : "No");
  } else {
    if (ok) puts(n & 1 ? "Yes" : "No");
    else {
      ll res = 0;
      for (int i = n; i >= 0; i--) {
        res = res * k + a[i];
        res %= mod;
      }
      puts(res == 0 ? "Yes" : "No");
    }
  }
  return 0;
}