2020.10.31,2020.11.1 考场代码

T1 挑战

40pts

#include <algorithm>
#include <cstdio>
#include <iostream>
#include <queue>
using namespace std;
inline int RD() {
  int intmp(0), insign(1);
  char rdch(getchar());
  while ((rdch != '-') && (rdch < '0' || rdch > '9')) {
    rdch = getchar();
  }
  if (rdch == '-') {
    insign = -1;
    rdch = getchar();
  }
  while (rdch >= '0' && rdch <= '9') {
    intmp *= 10;
    intmp += rdch - '0';
    rdch = getchar();
  }
  return intmp * insign;
}
int n, h, ans(0);
priority_queue<pair<int, int>> q;
struct Rm {
  int Pai, Mdc, Ls;
  bool operator<(const Rm &x) const { return this->Pai < x.Pai; }
} R[5005];
int main() {
  // freopen("ex2.in", "r", stdin);
  n = RD();
  h = RD();
  for (register int i(1); i <= n; ++i) {
    R[i].Pai = RD();
  }
  for (register int i(1); i <= n; ++i) {
    R[i].Mdc = RD();
    R[i].Ls = R[i].Mdc - R[i].Pai;
    q.push(make_pair(R[i].Mdc, i));
  }
  /*sort(R + 1, R + n + 1);
  for (register int i(1); i<= n; ++i) {
          printf("%d %d\n", R[i].Pai, R[i].Mdc);
  }*/
  while (h > 0 && q.size() > 0) {
    if (R[q.top().second].Pai > h) {
      q.pop();
      continue;
    }
    h += R[q.top().second].Ls;
    q.pop();
    ans++;
    // printf("%d %d\n", h, ans);
  }
  printf("%d\n", ans);
  /*while (1) {
    printf("%d\n", RD());
  }*/
  // system("pause");
  return 0;
}
/*
4 12
4 8 2 1
2 0 0 0

3


3 10
10 1 3
8 0 1

3


3 10
10 6 5
2  5 0

2

3 10
10 1 2
2 0 1
*/

T2 航班复杂度

25pts

#include <cstdio>
#include <iostream>
#include <queue>
using namespace std;
inline int RD() {
  int intmp(0), insign(1);
  char rdch(getchar());
  while ((rdch != '-') && (rdch < '0' || rdch > '9')) {
    rdch = getchar();
  }
  if (rdch == '-') {
    insign = -1;
    rdch = getchar();
  }
  while (rdch >= '0' && rdch <= '9') {
    intmp *= 10;
    intmp += rdch - '0';
    rdch = getchar();
  }
  return intmp * insign;
}
struct Edge;
struct Node {
  bool vsd, avl;
  int O, dep, rol;
  Edge *fst;
} N[100005];
struct Edge {
  Node *to;
  Edge *nxt;
} E[100005], *cnte(E);
int /* Om(0),*/ C_(0), rcnt(0);
bool flg(0);
void Lk(const int &A, const int &B) {
  (++cnte)->to = N + B;
  cnte->nxt = N[A].fst;
  N[A].fst = cnte;
  ++N[A].O;
  // Om = max(N[A].O, Om);
  return;
}
void Tarjan() { return; }
void DFS(Node *now) {
  if (C_ == -1) {
    return;
  }
  if (now->vsd) {    //环根
    if (now->rol) {  //相交
      C_ = -1;
      return;
    }
    now->rol = ++rcnt;  //独立环接驳
    flg = 1;
    return;
  }
  now->vsd = 1;
  Edge *Sid(now->fst);
  while (Sid) {
    /*if(Sid->to->avl) {
            Sid = Sid->nxt;
            continue;
    }*/
    DFS(Sid->to);
    if (flg) {          //向上寻找独立环
      if (!now->rol) {  //中间节
        now->rol = rcnt;
        return;
      }
      if (now->rol < rcnt) {  //相交
        C_ = -1;
        return;
      }
      ++C_;  //独立环根
      flg = 0;
    }
    Sid = Sid->nxt;
  }
  return;
}
int m, n, A, B, ans(0);
bool _0(1);
long long feb[1005];
queue<Node> q;
int main() {
  n = RD();
  m = RD();
  for (register int i(1); i <= m; ++i) {
    A = RD();
    B = RD();
    Lk(A, B);
  }
  for (register int i(1); i <= n; ++i) {
    if (N[i].O > 1) {
      _0 = 0;
    }
  }
  if (_0) {
    printf("0\n");
    return 0;
  }
  for (register int i(1); i <= n; ++i) {
    if (N[i].avl) {
      continue;
    }
    DFS(&N[i]);
    if (C_ == -1) {
      printf("-1%d\n", i);
      return 0;
    }
    if (C_ >= 2) {
      printf("2\n");
      return 0;
    }
    ans = max(ans, C_);
    C_ = 0;
    rcnt = 0;
    for (register int i(1); i <= n; ++i) {
      N[i].vsd = 0;
      N[i].rol = 0;
    }
  }
  printf("%d\n", ans);
  /*q.push(N[1]);
  N[1].dep = 0;
  int Dep(0);
  /*feb[3] = 1;
  feb[4] = 1;
  for (register int i(5); i <= 159; ++i) {
          feb[i] = feb[i - 3] + feb[i - 2];
          printf("feb %d = %lld,  i^5 = %lld, bi = %lf\n", i, feb[i], (long
  long)i*i*i * i * i*i*i, (double)feb[i]/ i/ i/ i/i/i/i/i/i/i/i);
  }*/
  /*	while (q.front().dep <= 100 && q.size()) {
                  if(Dep < q.front().dep) {
                          printf("dep %d ans %d dep^3 %d\n", Dep, ans, Dep* Dep
     * Dep);
                          ++Dep;
                  }
                  ans += max(0, q.front().O - 1);
                  Edge *Sd(q.front().fst);
                  while (Sd) {
                          Sd->to->dep = q.front().dep + 1;
                          q.push(*Sd->to);
                          Sd = Sd->nxt;
                  }
                  q.pop();
          }*/
  /*for (register int i(1); i <= n; ++i) {

  }*/
  /*while (1) {
    printf("%d\n", RD());
  }*/
  return 0;
}
/*
5 5
1 2
2 3
3 4
4 5
5 1

0

3 4
1 2
2 3
3 1
1 3

-1


3 3
1 2
2 1
1 3

1


4 5
1 2
2 1
2 3
3 4
4 3

2
*/

T3 数据生成器

40pts

#include <cstdio>
#include <iostream>
using namespace std;
inline int RD() {
	int intmp(0), insign(1);
	char rdch(getchar());
	while ((rdch != '-') && (rdch < '0' || rdch > '9')) {
		rdch = getchar();
	}
	if (rdch == '-') {
		insign = -1;
		rdch = getchar();
	}
	while (rdch >= '0' && rdch <= '9') {
		intmp *= 10;
		intmp += rdch - '0';
		rdch = getchar();
	}
	return intmp * insign;
}
int n, lst;
int L[3000005], R[3000005];
int ans[3000005];
int main() {
	//freopen("ex_generator2.in", "r", stdin);
	n = RD();
	/*for (register int i(1); i <= n; ++i) {

	}*/
	for (register int i(1); i <= n; ++i) {
		L[i] = RD();
		R[i] = RD();
		if(L[i - 1] > R[i]) {
			ans[i] = 1;
			lst = L[i];
		} else {
			ans[i] = ans[i - 1] + 1;
			lst = max(lst,L[i]);
		}
		ans[0] = max(ans[0], ans[i]);
	}
	printf("%d\n", ans[0]);
	/*while (1) {
		printf("%d\n", RD());
	}*/
	return 0;
}
/*
6
6 10
1 5
4 8
2 5
6 8
3 5
*/

T4 排列组合

10pts

#include <cstdio>
#include <iostream>
using namespace std;
inline int RD() {
	int intmp(0), insign(1);
	char rdch(getchar());
	while ((rdch != '-') && (rdch < '0' || rdch > '9')) {
		rdch = getchar();
	}
	if (rdch == '-') {
		insign = -1;
		rdch = getchar();
	}
	while (rdch >= '0' && rdch <= '9') {
		intmp *= 10;
		intmp += rdch - '0';
		rdch = getchar();
	}
	return intmp * insign;
}
int n, k;
int a[205];
int Ma[205][205];
void DFS(int Dep, int now[205]) {
	if(Dep > k) {
		return;
	}
	for (register int i(1); i <= n; ++i) {
		for (register int j(i + 1); j <= i; j++) {
		}
	}
	return;
}
int main() {
	n = RD();
	k = RD();
	for (register int i(1); i <= n; ++i) {
		a[i] = RD();
		Ma[i][i] = a[i];
	}
	for (register int i(1); i <= n; ++i) {
		for (register int j(i + 1); j <= n; ++j) {
			Ma[i][j] = max(Ma[i][j - 1], a[j]);
		}
	}
	if(k == 1) {
		int ans = ((n * (n - 1)) >> 1) +1;
		for (register int l(1); l < n; ++l) {
			for (register int i = 1; i + l <= n; ++i) {
				if(a[i]==a[l+i] && Ma[i][i+l]==a[i]) {
					//printf("%d,%d %d\n", a[i], a[l +i], Ma[i][l+i]);
					ans -= n - 1;
				}
			}
		}
		printf("%d\n",ans);
		return 0;
	}
	printf("%d\n", ((n * (n - 1)) >> 1) +1);
	return 0;
}
/*
3 2
3 1 2


3 1
2 1 2

2

3 1
1 2 1

3
*/

T1 大大大

100pts

#include <cstdio>
#include <iostream>
using namespace std;
inline int RD() {
  int intmp(0), insi(1);
  char rdch(getchar());
  while ((rdch < '0' || rdch > '9') && rdch != '-') {
    rdch = getchar();
  }
  if (rdch == '-') {
    insi = -1;
    rdch = getchar();
  }
  while (rdch >= '0' && rdch <= '9') {
    intmp = intmp * 10 + rdch - '0';
    rdch = getchar();
  }
  return intmp * insi;
}
long long n, m, ans(0);
int main() {
  /*while (1) {
    printf("%d\n", RD());
  }*/
  // n = RD();
  n = 7699;
  // for (n = 1; n <= (1000); n += 11) {
  // n^3 Force 30 pts
  /*ans = 0;
  for (register int i(1); i <= n; ++i) {
    for (register int j(1); j <= n; ++j) {
      for (register int k(1); k <= n; ++k) {
        if (i * j < k) {
          ++ans;
        }
      }
    }
  }
  printf("%lld -> %lld  %lld\n", n, ans, n * n * n - ans);*/

  // n ^ 2 force 60 pts
  ans = 0;
  for (register int k(2); k <= n; ++k) {
    for (register int j(1); j < k; ++j) {
      ans += (k - 1) / j;
    }
  }
  printf("%lld -> %lld  %lld\n", n, ans, n * n * n - ans);

  // n ^ (3/2) 100 pts
  ans = 0;
  for (register int i(1); i <= n; ++i) {
    for (register int j(1); j * i <= n; ++j) {
      ans += n - i * j + 1;
    }
  }
  printf("%lld -> %lld %lld\n", n, ans, n * n * n - ans);
  //}
  /*for (register int i(1); i <= n; ++i) {
    for (register int j(1); j * i <= n; ++j) {
      ans += n - i * j;
    }
  }
  printf("%lld\n", n * n * n - ans);*/
  system("pause");
  return 0;
}

T1club

#include <cstdio>
#include <iostream>
using namespace std;
inline int RD() {
  int intmp(0), insi(1);
  char rdch(getchar());
  while ((rdch < '0' || rdch > '9') && rdch != '-') {
    rdch = getchar();
  }
  if (rdch == '-') {
    insi = -1;
    rdch = getchar();
  }
  while (rdch >= '0' && rdch <= '9') {
    intmp = intmp * 10 + rdch - '0';
    rdch = getchar();
  }
  return intmp * insi;
}
long long n, m, ans1(0), ans2(0), ans3(0);
int main() {
  /*while (1) {
    printf("%d\n", RD());
  }*/
  // n = RD();
  for (n = 7699; n <= (100000); ++n) {
    // n^3 Force 30 pts
    /*ans1 = 0;
    for (register int i(1); i <= n; ++i) {
      for (register int j(1); j <= n; ++j) {
        for (register int k(1); k <= n; ++k) {
          if (i * j < k) {
            ++ans1;
          }
        }
      }
    }*/
    // printf("%lld -> %lld  %lld\n", n, ans, n * n * n - ans);

    // n ^ 2 force 60 pts
    ans2 = 0;
    for (register int k(2); k <= n; ++k) {
      for (register int j(1); j < k; ++j) {
        ans2 += (k - 1) / j;
      }
    }
    // printf("%lld -> %lld  %lld\n", n, ans, n * n * n - ans);

    // n ^ (3/2) 100 pts
    ans3 = 0;
    for (register int i(1); i <= n; ++i) {
      for (register int j(1); j * i <= n; ++j) {
        ans3 += n - i * j;
      }
    }
    if (/*ans1 == ans2 && */ ans2 == ans3) {
      printf("AC %lld %lld\n", n, n * n * n - ans2);
    } else {
      printf("WA %lld %lld %lld", n, /* n * n * n - ans1,*/ n * n * n - ans2,
             n * n * n - ans2);
      break;
    }
  }
  /*
  for (register int i(1); i <= n; ++i) {
    for (register int j(1); j * i <= n; ++j) {
      ans += n - i * j;
    }
  }*/
  // printf("%lld\n", n * n * n - ans);
  system("pause");
  return 0;
}

T2 kkk

0pts

#include <cstdio>
#include <cstring>
#include <iostream>
using namespace std;
inline int RD() {
  int intmp(0), insi(1);
  char rdch(getchar());
  while ((rdch < '0' || rdch > '9') && rdch != '-') {
    rdch = getchar();
  }
  if (rdch == '-') {
    insi = -1;
    rdch = getchar();
  }
  while (rdch >= '0' && rdch <= '9') {
    intmp = intmp * 10 + rdch - '0';
    rdch = getchar();
  }
  return intmp * insi;
}
int n, m, k, p, l, t;
int A, B, C;
int a[505];
int fy[505][505];
bool /*f[505][505][25],*/ flg(0);  // i 到 j 有 %p=k 的路径
struct Edge;
struct Node {
  Edge *fst;
  bool imp;
} N[505];
struct Edge {
  Node *to;
  Edge *nxt;
  int Val;
} E[505], *cnte(E + 0);
inline void Clr() {
  memset(N, 0, sizeof(N));
  // memset(f, 0, sizeof(f));
  memset(fy, 0, sizeof(fy));
  memset(a, 0, sizeof(a));
  flg = 0;
  return;
}
inline void Lk(const int &x, const int &y, const int &v) {
  /* (++cnte)->to = N + y;
   cnte->nxt = N[x].fst;
   N[x].fst = cnte;
   cnte->Val = v;*/
  // f[x][y][v] = 1;
  fy[x][y] |= (1 << v);
  return;
}
int main() {
  /*while (1) {
    printf("%d\n", RD());
  }*/
  t = RD();
  for (register int T(1); T <= t; ++T) {
    Clr();
    n = RD();
    m = RD();
    k = RD();
    p = RD();
    l = RD();
    cnte = E + 0;
    for (register int i(1); i <= k; ++i) {
      a[i] = RD();
      // printf("%d %d\n", i, a[i]);
      // N[a[i]].imp = 1;
    }
    /*for (register int i(1); i <= k; ++i) {
      printf("%d\n", a[i]);
    }*/
    for (register int i(1); i <= m; ++i) {
      A = RD();
      B = RD();
      C = RD();
      Lk(A, B, C);
      Lk(B, A, C);
    }
    for (register int i(1); i <= n; ++i) {
      fy[i][i] |= 1;
    }
    // floyd
    for (register int j(1); j <= n; ++j) {
      for (register int i(1); i <= n; ++i) {
        // if (k != i) {
        for (register int ik(0); ik < p; ++ik) {
          if (fy[i][j] & (1 << ik)) {
            for (register int e(1); e <= n; ++e) {
              // if (e != k && e != i) {
              // for (register int j(0); j < p; ++j) {
              // f[i][e][j] |= f[k][e][(j + p - ik) % p];
              fy[i][e] |= fy[j][e] >> ik;
              fy[i][e] |= (fy[j][e] & ((1 << ik) - 1)) << (p - ik);
              // }
              // }
            }
          }
        }
        // }
      }
    }
    /*   for (register int i(1); i <= n; ++i) {
         for (register int j(1); j <= n; ++j) {
           for (register int kk(0); kk < p; ++kk) {
             if (fy[i][j] & (1 << kk)) {
               printf("%d to %d len %d\n", i, j, kk);
             }
           }
         }
       }*/
    for (register int i(1); i <= k; ++i) {
      if (flg) {
        break;
      }
      for (register int j(i); j <= k; ++j) {
        // printf("%d %d %d %d\n", i, j, a[i], a[j]);
        if (fy[a[i]][a[j]] & (1 << l)) {
          printf("YES\n");
          flg = 1;
          break;
        }
      }
    }
    if (flg) {
      continue;
    }
    printf("NO\n");
  }
  system("pause");
  return 0;
}
/*
4
2 2 2 5 3
1 2
1 2 1
2 1 1
2 2 2 5 0
1 2
1 2 1
2 1 1
2 2 2 5 1
1 2
1 2 1
2 1 1
3 2 2 4 3
1 3
1 2 1
2 3 1

YES
YES
YES
NO

1
3 2 2 4 3
1 3
1 2 1
2 3 1
*/

T3 A的B次方

40pts

#include <cstdio>
#include <cstring>
#include <iostream>
using namespace std;
inline long long RD() {
  long long intmp(0), insi(1);
  char rdch(getchar());
  while ((rdch < '0' || rdch > '9') && rdch != '-') {
    rdch = getchar();
  }
  if (rdch == '-') {
    insi = -1;
    rdch = getchar();
  }
  while (rdch >= '0' && rdch <= '9') {
    intmp = intmp * 10 + rdch - '0';
    rdch = getchar();
  }
  return intmp * insi;
}
int n, m, k, l, t;
int p;
long long a, b;
bool f[505][505][25], flg(0);  // i 到 j 有 %p=k 的路径
int ksm(int x, long long y) {
  if (y == 0) {
    return 1;
  }
  if (y == 1) {
    return x;
  }
  int tmp = ksm(x, y >> 1);
  tmp = (long long)tmp * tmp % p;
  if (y % 2) {
    return (int)((long long)(x)*tmp % p);
  }
  return tmp;
}
int main() {
  /*while (1) {
    printf("%d\n", RD());
  }*/
  /*p = 0x3f3f3f3f;
  while (1) {
    a = RD();
    b = RD();
    printf("%d\n", ksm((int)(a % p), b));
  }*/
  a = RD();
  p = RD();
  for (register long long i(1); i <= 1005; ++i) {
    if (ksm(int(a % p), i) == ksm(int(i % p), a) && (i != a)) {
      printf("%lld\n", i);
      // break;
    }
  }
  system("pause");
  return 0;
}

T4 灯塔

20pts

#include <cstdio>
#include <cstring>
#include <iostream>
using namespace std;
inline long long RD() {
  long long intmp(0), insi(1);
  char rdch(getchar());
  while ((rdch < '0' || rdch > '9') && rdch != '-') {
    rdch = getchar();
  }
  if (rdch == '-') {
    insi = -1;
    rdch = getchar();
  }
  while (rdch >= '0' && rdch <= '9') {
    intmp = intmp * 10 + rdch - '0';
    rdch = getchar();
  }
  return intmp * insi;
}
bool flg(0);
int n, ans(0), tmp(0);
int a[3000005];
int dfrlt[3000005];
int lst[3000005];
int main() {
  /*while (1) {
    printf("%d\n", RD());
  }*/
  n = RD();
  lst[0] = 0;
  for (register int i(1); i <= n; ++i) {
    a[i] = RD();
  }
  if (n > 10000) {
    for (register int i(1); i <= n; ++i) {
      ++dfrlt[i + 1];
      --dfrlt[min(i + a[i] + 1, n)];
      lst[i] = lst[i - 1] + dfrlt[i];
      // printf("%d -- %d\n", i, lst[i]);
      tmp = 0;
      for (register int j(max(1, i - a[i])); j < i - 1; ++j) {
        tmp = max(lst[j], tmp);
      }
      ans ^= tmp;
      // printf("%d %d\n", i, tmp);
    }
    printf("%d\n", ans);
    // system("pause");
    return 0;
  }
  ans = 0;
  for (register int k(1); k <= n; ++k) {
    tmp = 0;
    for (register int i(1); i < k - 1; ++i) {
      for (register int j((k + i + 1) >> 1); j < k; ++j) {
        if (j <= i + a[i] && j >= k - a[k]) {
          ++tmp;
          break;
        }
      }
    }
    printf("%d %d\n", k, tmp);
    ans ^= tmp;
  }
  printf("%d\n", ans);
  system("pause");
  return 0;
}