2016华农校赛

9/10

题A 18114 Ly and PostCards

题意：要发明信片，有n个人，选其中的k个人来发，但是有一个规定，就是选了a的话，如果a和b关系好的，b也要寄给，所以给出m对关系好的，让你随机选k个人，求最后要发给的人数的期望，为了不输出浮点数，就将结果乘以C（n，k）；

题解：期望题一般都是考虑各种情况，把所有情况都考虑清晰之后，将数加起来平均一下就可以得出答案。考虑一个人，如果选了他，那么C（n，k）中有多少种情况会导致选这个人呢？假设这个人的前面有cnt个人，也就是只要选了这cnt个人的其中一个的话，那么就会选到这个人，然后共有C（n，k）- C（n - cnt， k）种是会选到这cnt个人的，所以考虑每个点dfs一次算出cnt就可以了。

/*zhen hao*/
#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;

typedef long long ll;
const int maxn = 55, maxm = 1e5 + 10;
int n, m, k, tot;
int head[maxn], cnt[maxn];
ll c[maxn][maxn];
bool vis[maxn];

struct Edge {
  int v, next;
  Edge(int v=0, int next=0) : v(v), next(next) {}
} edges[maxm];

void init() {
  c[0][0] = 1;
  for (int i = 1; i < maxn; i++) {
    c[i][0] = c[i - 1][0];
    for (int j = 1; j <= i; j++)
      c[i][j] = c[i - 1][j] + c[i - 1][j - 1];
  }

  memset(head, -1, sizeof head);
  tot = 0;
}

void add_edge(int u, int v) {
  edges[tot] = Edge(v, head[u]);
  head[u] = tot++;
}

void dfs(int u) {
  vis[u] = 1;
  for (int i = head[u]; ~i; i = edges[i].next) {
    int v = edges[i].v;
    if (!vis[v]) dfs(v);
  }
}

int main() {
//  freopen("case.in", "r", stdin);
  int T;
  cin >> T;
  while (T--) {
    scanf("%d%d%d", &n, &m, &k);
    init();
    for (int i = 0; i < m; i++) {
      int u, v;
      scanf("%d%d", &u, &v);
      add_edge(v, u);
    }
    for (int i = 1; i <= n; i++) {
      memset(vis, false, sizeof vis);
      dfs(i);
      cnt[i] = 0;
      for (int j = 1; j <= n; j++) cnt[i] += vis[j];
    }
    ll ans = 0;
    for (int i = 1; i <= n; i++) {
      ans += c[n][k] - c[n - cnt[i]][k];
    }
    cout << ans << endl;
  }
  return 0;
}

题B 18113 Secret Book of Kungfu

题意：定义一种数，该数的十进制表示是它的二进制表示的子串，求l，r中有多少个数满足？

题解：打表发现这种数只可能是0和1组成，那么对于这个区间的所有0和1组成的十进制数，暴力统计一下有多少个，打个表二分查找即可。

/*zhen hao*/
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <iostream>
#include <cmath>
#include <vector>
#include <queue>
#include <stack>
#include <string>
using namespace std;

typedef long long ll;
const ll inf = 1e15;
char s[100], t[100];
int dp[1 << 20], digit[100], cnt;
ll id[1 << 20];

int check(int l, int r) {
  int ret = 0;
  for (int i = l; i <= r; i++) {
    int ss = 0, st = 0;
    int x = i;
    while (x) {
      s[ss++] = (x % 2) + '0';
      x /= 2;
    }
    s[ss] = '';
    reverse(s,s + ss);
    x = i;
    while (x) {
      t[st++] = (x % 10) + '0';
      x /= 10;
    }
    t[st] = '';
    reverse(t, t + st);
    if (strstr(s, t) != NULL) {
      ret++;
    }
  }
  return ret;
}

int check(ll v) {
  ll x = v;
  int ss = 0, st = 0;
  while (x) {
    s[ss++] = (x % 2) + '0';
    x /= 2;
  }
  s[ss] = '';
  x = v;
  while (x) {
    t[st++] = (x % 10) + '0';
    x /= 10;
  }
  t[st] = '';
  return strstr(s, t) != NULL;
}

void init() {
  for (int i = 0; i < (1 << 16); i++) {
    ll val = 0;
    int x = i, len = 0;
    while (x) {
      digit[len++] = x % 2;
      x /= 2;
    }
    for (int j = len - 1; j >= 0; j--) val = val * 10 + digit[j];
    if (check(val)) dp[i] = dp[i - 1] + 1;
    else dp[i] = dp[i - 1];
    id[i] = val;
    cnt++;
    if (val > inf) break;
  }
}

int get_ans(ll n) {
  if (n == -1) return 0;
  if (n == 0) return 1;
  int len = 0;
  ll real = 0;
  while (n) {
    digit[++len] = n % 10;
    n /= 10;
  }
  bool flag = false;
  for (int i = len; i > 0; i--) {
    if (digit[i] > 1) flag = true;
    if (flag) real = real * 10 + 1;
    else real = real * 10 + digit[i];
  }
  int pos = lower_bound(id, id + cnt, real) - id;
  return dp[pos];
}

int main() {
//  freopen("case.in", "r", stdin);
  init();
  int T;
  cin >> T;
  while (T--) {
    ll l, r;
    cin >> l >> r;
    printf("%d
", get_ans(r) - get_ans(l - 1));
//    printf("%d
", check(l, r));
  }
  return 0;
}

题C 18116 M1crosoft Exce1

题意：模拟题

题解：搞不定啊！希望有生之年能够把bug搞定吧！！

题D 18117 Yys VS BetaCome

题意：给你一段连续的区间长度为n，每次可以取长度为1~m的连续区间，谁取到最后的线段算赢，问你最后谁赢。

题解：这题是全场最水的题目，当然是对于学过对称博弈的大神，对于我这种渣渣当然是一个dfs打个表就交上去了。说一下正解：当m = 1的时候判一下奇偶就好了，否则的话就一定是先手必胜，因为第一个人拿了中间长度之后，然后分成均匀的两端，左边的人怎么拿，同理拿右边的就好了，这样就一定能够获胜。下面就给出我这个渣渣打表的代码吧！

/*zhen hao*/
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <iostream>
#include <cmath>
#include <vector>
#include <queue>
#include <stack>
using namespace std;

const int maxn = 210, maxk = 110;
int dp[maxn][maxk];

int dfs(int n, int k) {
  if (dp[n][k] != -1) return dp[n][k];
  if (k >= n) return 1;
  bool ok = false;
  for (int i = 1; i <= k; i++)
    if (!dfs(n - i, k)) {
      ok = true; break;
    }
  if (!ok) {
    for (int i = 1; i <= k; i++) {
      for (int l = 1; l < n - i; l++) {
        int r = n - i - l;
        if (!(dfs(l, k) ^ dfs(r, k))) ok = true;
        if (ok) break;
      }
    }
  }
  return dp[n][k] = ok;
}

void init() {
  memset(dp, -1, sizeof dp);
  for (int i = 1; i <= 200; i++)
    for (int j = 1; j <= 40; j++)
      dp[i][j] = dfs(i, j);
}

int main() {
//  freopen("case.in", "r", stdin);
  init();
  int T;
  cin >> T;
  while (T--) {
    int n, k;
    cin >> n >> k;
    if (dp[n][k]) puts("yes");
    else puts("no");
  }
  return 0;
}

题E 18110 Koishi's travel, Satori's travel

题意：给你n个数，找出最大的ai % aj （i > j）

题解：这个数的范围是5e4，显然是从这里下手。然后对于一个数aj，模aj的数的结果如下：0 1 …… （ai - 1） 0 1 …… （ai - 1）这样循环地出现，所以每次我们检查一段段的看一下这一段的最大值是什么，这个显然可以用线段树进行维护，对于每个数要找n / ai次，每次logn，所以复杂度是O（nlog²n）；还有一个优化，对于每个相同的数，要考虑的肯定是最后一个，因为这样考虑的数更多。

 

/*zhen hao*/
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <iostream>
#include <cmath>
#include <vector>
#include <queue>
#include <stack>
#include <string>
using namespace std;

#define lson l, m, rt<<1
#define rson m+1, r, rt<<1|1

const int maxn = 5e4 + 10;
int last[maxn], _max[maxn * 4], v[maxn];

void PU(int rt) {
  _max[rt] = max(_max[rt * 2], _max[rt * 2 + 1]);
}

void build(int l, int r, int rt) {
  _max[rt] = 0;
  if (l == r) return;
  int m = (l + r) / 2;
  build(lson);
  build(rson);
}

void update(int u, int d, int l, int r, int rt) {
  if (l == r) {
    _max[rt] = d;
    return;
  }
  int m = (l + r) / 2;
  if (u <= m) update(u, d, lson);
  else update(u, d, rson);
  PU(rt);
}

int query(int ql, int qr, int l, int r, int rt) {
  if (ql <= l && r <= qr) {
    return _max[rt];
  }
  int m = (l + r) / 2, ret = 0;
  if (ql <= m) ret = max(ret, query(ql, qr, lson));
  if (qr > m) ret = max(ret, query(ql, qr, rson));
  return ret;
}

int main() {
//  freopen("case.in", "r", stdin);
  int T;
  cin >> T;
  while (T--) {
    int n;
    scanf("%d", &n);
    for (int i = 1; i <= n; i++) {
      scanf("%d", v + i);
      last[v[i]] = i;
    }
    build(0, n, 1);
    int ans = 0;
    for (int i = 1; i <= n; i++) {
      if (i == last[v[i]]) {
        int l = 0, r;
        while (l <= n) {
          r = min(n, l + v[i] - 1);
          int tmp = query(l, r, 0, n, 1);
//          printf("%d %d %d
", l, r, tmp);
          ans = max(ans, tmp % v[i]);
          l += v[i];
        }
      }
      update(v[i], v[i], 0, n, 1);
    }
    cout << ans << endl;
  }
  return 0;
}

题F 18115 Devon's 3D LED Cube

题意：给你n * m * k的开关和灯，然后开关有一个特性，就是按下这个开关之后对应的六个方向的开关（三维）都会取反，然后问你最少按下多少个开关可以得到灯全开的状态。

题解：这道题和BC的一道div1第三题很像，只不过换成三维的了。做法就是：枚举第一层（m * k）的开关状态，然后结合第一层的灯的起始和终止（已知）状态，可以推出第二层的开关状态，最后推导出最后一层的开关状态，然后在判断能不能将最后一层的开关给点亮。

 

#include <cstdio>
#include <cstring>
#include <cmath>
#include <iostream>
#include <algorithm>
#include <vector>
#include <queue>
#include <set>
#include <map>
#include <stack>
using namespace std;

const int maxn = 5, dx[] = {-1, 0, 0, 0, 0, 0}, dy[] = {0, 1, -1, 0, 0, 0}, dz[] = {0, 0, 0, 1, -1, 0}, inf = 1 << 20;
int n, m,k;
int v[maxn][maxn][maxn], s[maxn][maxn][maxn];

bool inside(int x, int y, int z) {
  return x >= 0 && x < n && y >= 0 && y < m && z >= 0 && z < k;
}

int get_around(int x, int y, int z) {
  int ret = 0;
  for (int i = 0; i < 6; i++) {
    int xx = x + dx[i], yy = y + dy[i], zz = z + dz[i];
    if (!inside(xx, yy, zz)) continue;
    ret += s[xx][yy][zz];
  }
  return ret;
}

bool check() {
  for (int i = 0; i < n - 1; i++)
    for (int j = 0; j < m; j++)
      for (int l = 0; l < k; l++) {
        s[i + 1][j][l] = (get_around(i, j, l) + v[i][j][l] + 1) % 2;
      }
  for (int j = 0; j < m; j++)
    for (int l = 0; l < k; l++) {
      int x = get_around(n - 1, j, l);
      if ((x + v[n - 1][j][l]) % 2 != 1) return false;
    }
  return true;
}

int main() {
//  freopen("case.in", "r", stdin);
  int T;
  cin >> T;
  while (T--) {
    scanf("%d%d%d", &n, &m, &k);
    for (int i = 0; i < n; i++)
      for (int j = 0; j < m; j++)
        for (int l = 0; l < k; l++)
          scanf("%d", &v[i][j][l]);
    int ans = inf, cnt = m * k;
    for (int i = 0; i < (1 << cnt); i++) {
      for (int j = 0; j < cnt; j++) {
        int x = j / k, y = j % k;
        if (i & (1 << j)) s[0][x][y] = 1;
        else s[0][x][y] = 0;
      }
      if (check()) {
        int temp = 0;
        for (int i = 0; i < n; i++)
          for (int j = 0; j < m; j++)
            for (int l = 0; l < k; l++)
              temp += s[i][j][l];
        ans = min(ans, temp);
      }
    }
    if (ans == inf) ans = -1;
    cout << ans << endl;
  }
  return 0;
}

题G 18108 chocola isn't so skillful

题意：给你一种形状有五个格子，然后有a b c d e满足a + b + c = d + e + c，这个c是共用的，且这五个数都不能相同，问你有多少种填法。

题解：这题数据范围很小，我们可以枚举a b c然后d已经确定了，然后c有多少种取法呢，就是n - 4,累计一下即可。

/*zhen hao*/
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <iostream>
#include <cmath>
#include <vector>
#include <queue>
#include <stack>
using namespace std;

int main() {
//  freopen("case.in", "r", stdin);
  int T;
  cin >> T;
  while (T--) {
    int n, ans = 0;
    scanf("%d", &n);
    for (int i = 1; i <= n; i++)
      for (int j = 1; j <= n; j++) if (i != j) {
        int s = i + j;
        for (int k = 1; k <= s; k++) if (k >= 1 && k <= n && k != i && k != j && k != s - k && s - k >= 1 && s - k <= n && s - k != i && s - k != j) {
          ans += (n - 4);
        }
      }
    cout << ans << endl;
  }
  return 0;
}

题H 18109 Koishi and Kokoro, no one loses

题意：给你n和m，然后求有多少个满足下列条件的长度为m的序列

（1）序列是非递减的

（2）序列的数的范围是【1，n】

（3）满足A[1] * A[2] * ...... * A[m] = lcm(A[1], A[2], ....,A[m]) * gcd(A[1], A[2],...A[m])

题解：实际上要想lcm * gcd必须是这m个数是互素的，所以题目就是求长度为m的互素的非递减序列有多少种？分析一下数据规模，n为100，里面的素因子种类有25个，我们观察可以发现，一个数存在两种素因子的最小的是50（5和2），在后面的数如果有两个素因子的话一定是50以内的，所以我们就可以用dp(i, j, k)表示长度为i的序列，考虑j这个数作为末尾，素因子的状态为k，由于50以内有15个素因子，所以k的取值为（1 << 15）;然后就是转移了，显然枚举j + 1 …… 100作为末尾，但前提是对k状态没有冲突，这个要写一个函数来判断，然后加进这个数之后状态有什么变化，也要写个函数。对于这两个函数的所有结果用两个数组分别保存，最后记得统计一下答案即可。

 

/*zhen hao*/
#include <cstdio>
#include <iostream>
#include <cstring>
#include <algorithm>
#include <cmath>
#include <vector>
using namespace std;

typedef long long ll;
const int mod = 1e9 + 7;
int dp[30][110][1 << 15], id[110], prime[110], f[110], to[110][1 << 15];
int ans[40][140];
bool vis[110][1 << 15];


bool check(int x, int s) {
  for (int i = 0; i < 15; i++) if (x % prime[i] == 0) {
    if (s & (1 << i)) return false;
  }
  return true;
}

int get_status(int x, int s) {
  for (int i = 0; i < 15; i++) if (x % prime[i] == 0) {
    s |= (1 << i);
  }
  return s;
}

void init() {
  id[0] = id[1] = 1;
  for (int i = 2; i <= 50; i++) if (!id[i])
    for (int j = i + i; j <= 50; j += i) id[j] = 1;
  int cnt = 0;
  for (int i = 2; i <= 50; i++)
    if (!id[i]) prime[cnt++] = i;
//  for (int i = 0; i < cnt; i++) cout << prime[i] << ' ';
//  cout << cnt << endl;
  for (int x = 2; x <= 100; x++)
    for (int y = 0; y < (1 << 15); y++) if (check(x, y)) {
        vis[x][y] = 1;
        to[x][y] = get_status(x, y);
      }
}

void add(int& a, int b) {
  a += b;
  if (a >= mod) a -= mod;
}

void slove() {
  dp[0][0][0] = 1;
  for (int i = 0; i < 25; i++) {
    for (int j = i; j <= 100; j++) {
      for (int k = 0; k < (1 << 15); k++) if (dp[i][j][k]) {
//        cout << i << ' ' << j << ' ' << k << endl;
        for (int x = max(2, j + 1); x <= 100; x++) if (vis[x][k])
          add(dp[i + 1][x][to[x][k]], dp[i][j][k]);
      }
    }
  }
  for (int i = 1; i <= 25; i++) {
    for (int j = i; j <= 100; j++) {
      for (int k = 0; k < (1 << 15); k++) {
        add(ans[i][j], dp[i][j][k]);
      }
    }
  }
}

int get_ans(int n, int m) {
  int ret = 1;
  for (int i = 1; i <= min(25, m); i++)
    for (int j = i; j <= min(100, n); j++)
      add(ret, ans[i][j]);
  return ret;
}

int main() {
//  freopen("case.in", "r", stdin);
  init();
  slove();
  int T;
  scanf("%d", &T);
  while (T--) {
    int n, m;
    scanf("%d%d", &n, &m);
    if (m == 2) printf("%d
", n * (n + 1) / 2);
    else {
      printf("%d
", get_ans(n, m));
    }
  }
  return 0;
}

题I 18111 Maximum Perimeter

题意：给你一个四边形，让你切成两个三角形，然后组成的三角形周长最大。

题解：首先要看这个四边形是不是凸的。如果是凸的，直接枚举两种情况，如果不是，那么就找出那个导致四边形是凹的的点，然后直接和另外一个点分成两个三角形即可。

 

/*zhen hao*/
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <iostream>
#include <cmath>
#include <vector>
#include <queue>
#include <stack>
#include <string>
using namespace std;

const double eps = 1e-8;

int sgn(double x) {
  if (fabs(x) < eps) return 0;
  if (x < 0) return -1;
  return 1;
}

struct Point {
  double x, y;
  Point() {}
  Point(double _x, double _y) {
    x = _x; y = _y;
  }
  void input() {
    scanf("%lf%lf", &x, &y);
  }
  double operator ^ (const Point& b) const {
    return x * b.y - y * b.x;
  }
  Point operator - (const Point& b) const {
    return Point(x - b.x, y - b.y);
  }
  double dist(Point b) {
    return sqrt((x - b.x) * (x - b.x) + (y - b.y) * (y - b.y));
  }
  double operator * (const Point& b) const {
    return x * b.x + y * b.y;
  }
};

struct Polygon {
  int n;
  Point p[5];
  int relationpoint(Point q) {
    int cnt = 0;
    for (int i = 0; i < n; i++) {
      int j = (i + 1) % n;
      int k = sgn((q - p[j]) ^ (p[i] - p[j]));
      int u = sgn(p[i].y - q.y);
      int v = sgn(p[j].y - q.y);
      if (k > 0 && u < 0 && v >= 0) cnt++;
      if (k < 0 && v < 0 && u >= 0) cnt--;
    }
    return cnt != 0;
  }
};

Polygon poly[10];
Point p[5];

int main() {
//  freopen("case.in", "r", stdin);
  int T;
  cin >> T;
  while (T--) {
    int n = 4;
    for (int i = 0; i < n; i++) p[i].input();
    for (int i = 0; i < n; i++) {
      int cnt = 0;
      for (int j = 0; j < n; j++) if (i != j) poly[i].p[cnt++] = p[j];
      poly[i].n = cnt;
    }
    int t = -1;
    for (int i = 0; i < n; i++) {
      if (poly[i].relationpoint(p[i])) { t = i; break; }
    }
    double ans = 0;
    for (int i = 0; i < 4; i++) ans += p[i].dist(p[(i + 1) % n]);
    if (t == -1) {
      ans += max(p[0].dist(p[2]) * 2, p[1].dist(p[3]) * 2);
    } else {
      ans += p[t].dist(p[(t + 2) % 4]) * 2;
    }
    printf("%.3lf
", ans);
  }
  return 0;
}

题J 18112 Play Ball

题意：一开始给你一个人，坐标和速度，然后给你目标点，然后在给你n个可以辅助的人，做斜抛运动，然后问你最短时间到目标点。

题解：设这个时间为t，然后有

L = Vx t

Vy = g（t/2）

然后联立成一个一元二次方程再判有没有解即可，无解就说明这两个点是inf，注意每个人都有一个速度，所以是有向边。在最后跑一次最短路就行了。

 

/*zhen hao*/
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <iostream>
#include <cmath>
#include <vector>
#include <queue>
#include <stack>
#include <string>
using namespace std;

typedef long long ll;
const int maxn = 20, maxm = 1e3 + 10;
const double inf = 1e10;
double dist[maxn];
int n, tot, head[maxn], done[maxn];

struct Point {
  double x, y, v;
  void input() {
    scanf("%lf%lf%lf", &x, &y, &v);
  }
  double dist(Point o) {
    double a = 25.0, b = v * v, c = (x - o.x) * (x - o.x) + (y - o.y) * (y - o.y);
    double delta = b * b - 4 * a * c;
    if (delta < 0) return inf;
    double x1 = (b - sqrt(delta)) / (2.0 * a), x2 = (b + sqrt(delta)) / (2.0 * a);
    if (x1 > 0 && x2 > 0) return sqrt(min(x1, x2));
    if (x1 < 0 && x2 < 0) return inf;
    return sqrt(max(x1, x2));
  }
} p[maxn];

struct Edge {
  int v;
  double w;
  int next;
  Edge(int v=0, double w=0, int next=0) : v(v), w(w), next(next) {}
} edges[maxm];

struct Node {
  double d;
  int u;
  Node(double d=0, int u=0) : d(d), u(u) {}
  bool operator < (const Node& o) const {
    return d > o.d;
  }
};

void init() {
  tot = 0;
  memset(head, -1, sizeof head);
}

void add_edge(int u, int v, double w) {
  edges[tot] = Edge(v, w, head[u]);
  head[u] = tot++;
}

void dijkstra() {
  for (int i = 0; i <= n; i++) dist[i] = inf;
  memset(done, 0, sizeof done);
  dist[0] = 0;
  priority_queue<Node> pq;
  pq.push(Node(0, 0));
  while (!pq.empty()) {
    Node r = pq.top(); pq.pop();
    int u = r.u;
    if (done[u]) continue;
    done[u] = 1;
    for (int i = head[u]; ~i; i = edges[i].next) {
      Edge& e = edges[i];
      if (dist[e.v] > dist[u] + e.w) {
        dist[e.v] = dist[u] + e.w;
        pq.push(Node(dist[e.v], e.v));
      }
    }
  }
}


int main() {
//  freopen("case.in", "r", stdin);
  int T;
  cin >> T;
  while (T--) {
    p[0].input();
    scanf("%d", &n);
    for (int i = 1; i <= n; i++) p[i].input();
    ++n;
    scanf("%lf%lf", &p[n].x, &p[n].y);

    init();
    for (int i = 0; i < n; i++)
      for (int j = 0; j <= n; j++) if (i != j) {
        double w = p[i].dist(p[j]);
        if (w != inf) add_edge(i, j, w);
      }
    dijkstra();
    printf("%.3lf
", dist[n]);
  }
  return 0;
}

最后一个福利：题目 + 州神题解

传送门