HZNU Training 4 for Zhejiang Provincial Collegiate Programming Contest 2019

时间 2019-12-18

标签 hznu training zhejiang provincial collegiate programming contest 繁體版

原文原文链接

今日这场比赛咱们准备的题比较全面，二分+数论+最短路+计算几何+dp+思惟+签到题等。有较难的防AK题，也有简单的签到题。为你们准备了一份题解和AC代码。node

A - Meeting with Aliens

UVA - 10570 ios

题目意思：让一个成环的序列变成有序的，正序逆序均可以，问最小交换次数。算法

解题思路：对于一个长度为n的元素互异的序列，经过交换实现有序的最小的交换次数是=n - 被分解成单循环的个数。数据比较小，正着来一遍，反着来一遍，取最小就能够了。数组

#include<iostream>
#include<algorithm>
#include<cstdio>
#include<cstring>
#include<cmath>
#include<queue>
#include<set>
#include<map>
#include<string>
#include<vector>
#include<ctime>
#include<stack>
using namespace std;
#define inf 0x3f3f3f3f
#define mm(a,b) memset(a,b,sizeof(a))
#define ll long long
#define MAXN 101000
#define mod ((int)1e9+7)

const int maxn = 500 + 10;

int n;
int num[maxn << 1];
bool vis[maxn];

void dfs(int st, int a) {
    if (vis[a]) return;
    vis[a] = true;
    dfs(st, num[st + a - 1]);
}

void dfs2(int st, int a) {
    if (vis[a]) return;
    vis[a] = true;
    dfs2(st, num[st - a + 1]);
}

int main()
{
    //freopen("input.txt", "r", stdin);
    while (~scanf("%d", &n) && n) {
        for (int i = 0; i < n; i++) {
            scanf("%d", &num[i]);
            num[i + n] = num[i];
        }

        int Max = 0;

        for (int st = 0; st < n; st++) {
            memset(vis, false, sizeof(vis));
            int cnt = 0;
            for (int i = st; i < st + n; i++) {
                if (!vis[num[i]]) {
                    dfs(st, num[i]);
                    cnt++;
                }
            }
            Max = Max > cnt ? Max : cnt;
        }

        for (int st = 2 * n - 1; st >= n; st--) {
            memset(vis, false, sizeof(vis));
            int cnt = 0;
            for (int i = st; i >= st - n + 1; i--) {
                if (!vis[num[i]]) {
                    dfs2(st, num[i]);
                    cnt++;
                }
            }
            Max = Max > cnt ? Max : cnt;
        }

        printf("%d\n", n - Max);
    }
    return 0;
}

View Code

B - Bi-shoe and Phi-shoe

LightOJ - 1370 ide

欧拉函数函数

题意：给定值，求知足欧拉值大于等于这个数的最小的数。this

题解：预处理存下来，从x+1(x是幸运数字)开始找第一个出现的素数，那就是最小花费。spa

/*

 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 I have a dream!A AC deram!!
 orz orz orz orz orz orz orz orz orz orz orz
 orz orz orz orz orz orz orz orz orz orz orz
 orz orz orz orz orz orz orz orz orz orz orz

 */

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
#include<string>
#include<algorithm>
#include<vector>
#include<queue>
#include<set>
#include<map>
#include<stack>
#include<stdlib.h>
using namespace std;
typedef long long LL;
typedef unsigned long long int ull;
const int inf = 0x3f3f3f3f;
const int mod = 1e9 + 7;
const int maxn = 2000 + 5;
int euler[1001000];
void Is_prime()
{
    memset(euler,0,sizeof(euler));
    euler[1]=1;
    for(int i=2;i<=1000;i++)
    {
        if(!euler[i])
        {
            for(int j=2*i;j<1000000+100;j+=i)
            {
                euler[j]=1;
            }
        }
    }
}
int main()
{
    int T,t=0;
    scanf("%d",&T);
    Is_prime();
    while(T--)
    {
        int n;
        scanf("%d",&n);
        LL ans=0;
        for(int i=0;i<n;i++)
        {
            int x;
            scanf("%d",&x);
            for(int j=x+1;;j++)
            {
                if(!euler[j])
                {
                    ans+=j;
                    break;
                }
            }
        }
        printf("Case %d: %lld Xukha\n",++t,ans);
    }
}

View Code

C - Highways

POJ - 1751 .net

题意：首行给出N，表明有1~N共N个点。接下来N行，每行两个数x，y，表明第i个点的坐标。接着给出M，接着M行，每行两个数x，y，表明第x个点和第y个点已经联通（即x到y的权值为0）,创建最小生成树，输出生成树中权值不为0的边的两端的点的编号。code

题解：最坏的状况须要遍历图中的每一条边，很明显的稠密图，优先选用普利姆算法。根据坐标创建无向图，权值设为距离的平方便可，这样能够避免sqrt后权值变为double型，避免精度损失。对于已联通的两点，更新这两点的权值为0便可。

#include<iostream>
#include<algorithm>
#include<cstdio>
#include<cstring>
#include<cmath>
#include<queue>
#include<set>
#include<string>
#include<vector>
#include<ctime>
#include<stack>
using namespace std;
#define inf 0x3f3f3f3f
#define mm(a,b) memset(a,b,sizeof(a))
#define ll long long
#define MAXN 101000
#define mod ((int)1e9+7)
const int maxn=751;
const int INF=0x3f3f3f3f;
int map[maxn][maxn];
int dis[maxn];
int vis[maxn];
int Edge[maxn];//i到Edge[i]是一条生成树内的边
struct node
{
    int x;
    int y;
} Point[maxn]; //第i个点的坐标
int N;//点的数量
int M;//更新边的数量
void init()
{
    scanf("%d",&N);
    for(int i=1; i<=N; i++)//建图
    {
        scanf("%d%d",&Point[i].x,&Point[i].y);
        for(int j=1; j<i; j++)//为何这里不取sqrt，由于彻底不必
            map[i][j]=map[j][i]=(Point[i].x-Point[j].x)*(Point[i].x-Point[j].x)+(Point[i].y-Point[j].y)*(Point[i].y-Point[j].y);
        map[i][i]=INF;//本身不可能到本身
    }
    scanf("%d",&M);
    int x,y;
    while(M--)//更新图
    {
        scanf("%d%d",&x,&y);
        map[x][y]=map[y][x]=0;
    }
    memset(vis,0,sizeof(vis));
    vis[1]=1;
    for(int i=1; i<=N; i++)
    {
        dis[i]=map[i][1];
        Edge[i]=1;//初始化为存储i到1的边
    }
}
void Prim()
{
    for(int i=1; i<N; i++)
    {
        int minn=INF;
        int point_minn;
        for(int j=1; j<=N; j++)
            if(vis[j]==0&&minn>dis[j])
            {
                minn=dis[j];
                point_minn=j;
            }
        vis[point_minn]=1;
        for(int k=1; k<=N; k++)
            if(vis[k]==0&&dis[k]>map[point_minn][k])
            {
                Edge[k]=point_minn;//这里是输出方式的技巧
                dis[k]=map[point_minn][k];
            }
        if(map[Edge[point_minn]][point_minn])
            printf("%d %d\n",Edge[point_minn],point_minn);
    }
}
int main()
{
    init();
    Prim();
    return 0;
}

View Code

D - Maze

CodeForces - 377A

题意：给你一个图，将k个‘.’变成‘X’，使剩下的‘.’仍然连通，图中还有‘#’。

题解：思惟关键点是既然他要你修改k个，那么假设一开始有s个，则dfs搜索到k-s个的时候中止就行了，没被搜索到的就是要修改的，这样能够保证剩下的一定连通。

#include <iostream>
#include <cstdio>
#include <cstring>
int n,m,k;
int go[4][2]={0,1,1,0,0,-1,-1,0};
char map[505][505];
int book[505][505];
using namespace std;
void dfs(int r,int c)
{
    if(!k)
    return ;
    k--;
    //map[r][c]='0';
    book[r][c]=1;//将要修改的标记出来，注意这里不能在回溯过程当中再将标记取消
    for(int i=0;i<4;i++)
    {
        int tr=r+go[i][0];
        int tc=c+go[i][1];
        if(tr>=0&&tr<n&&tc>=0&&tc<m&&!book[tr][tc]&&map[tr][tc]=='.')
        {
            dfs(tr,tc);
        }
    }
}
int main()
{
    scanf("%d%d%d",&n,&m,&k);
    getchar();
    int t=0;
    for(int i=0;i<n;i++)
    {
        for(int j=0;j<m;j++)
    {
        scanf("%c",&map[i][j]);
        if(map[i][j]=='.')
        t++;
    }
    getchar();
    }
    k=t-k;
    int flag=1;
    for(int i=0;i<n&&flag;i++)
    {
        for(int j=0;j<m&&flag;j++)
    {
        if(map[i][j]=='.')//从第一个.开始搜索
        {
            //book[i][j]=1;
            dfs(i,j);
            flag=0;
        }
        
    }
    }
    for(int i=0;i<n;i++)
    {
        for(int j=0;j<m;j++)
    {
        //printf("%d ",book[i][j]);
        if(map[i][j]=='.'&&!book[i][j])//没被搜索到的修改
        {
            putchar('X');
        }
        //else if(map[i][j]=='.')
        //putchar('X');
        else
        printf("%c",map[i][j]);
        
    }
    printf("\n");
    }
return 0;
}

View Code

E - Justice Rains From Above

Gym - 101194K

题意：计算几何。在一个三维空间里，法鸡在某一点，她会发射攻击，攻击是一个圆锥，而后给你几个敌人的坐标，问最多能消灭几个敌人。

2016-2017ICPC-China final的题目，问学军的学弟要来的。

你们自行体会一下。

#pragma GCC optimize(2)
#pragma GCC optimize("inline")
#pragma GCC optimize("fast-math")
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <tuple>
#include <cmath>
using namespace std;
 
typedef double real;
const real eps = 1e-12, pi = acos(-1);

inline int fcmp(real x, real y) {
  return fabs(x - y) < eps ? 0 : x < y ? -1 : 1;
}

struct vec {
  real x, y;
  vec operator + (const vec &b) const { return {x + b.x, y + b.y}; }
  vec operator + (void) const { return {x, y}; }
  vec operator - (const vec &b) const { return {x - b.x, y - b.y}; }
  vec operator - (void) const { return {-x, -y}; }
  vec operator * (const vec &b) const
  { return {x * b.x - y * b.y, x * b.y + y * b.x}; }
  vec operator * (real b) const { return {x * b, y * b}; }
  vec operator / (real b) const { return {x / b, y / b}; }
  real dot(const vec &b) const { return x * b.x + y * b.y; }
  real det(const vec &b) const { return x * b.y - y * b.x; }
  real norm(void) const { return x * x + y * y; }
  real len(void) const { return sqrt(norm()); }
  real angle(void) const { return atan2(y, x); }
  vec unit(void) const { return *this / len(); }
  vec perp(void) const { return {-y, x}; }
  bool operator < (const vec &b) const
  { return fcmp(x, b.x) ? x < b.x : fcmp(y, b.y) < 0; }
  bool operator > (const vec &b) const
  { return fcmp(x, b.x) ? x > b.x : fcmp(y, b.y) > 0; }
  bool operator <= (const vec &b) const
  { return fcmp(x, b.x) ? x < b.x : fcmp(y, b.y) <= 0; }
  bool operator >= (const vec &b) const
  { return fcmp(x, b.x) ? x > b.x : fcmp(y, b.y) >= 0; }
  bool operator == (const vec &b) const
  { return fcmp(x, b.x) == 0 && fcmp(y, b.y) == 0; }
  bool operator != (const vec &b) const
  { return fcmp(x, b.x) != 0 || fcmp(y, b.y) != 0; }
};

struct Line {
  vec u, v;
};

struct Circle {
  vec o;
  real r;
};

vec Foot(const Line &l, const vec &p) {
  return l.u + l.v * (l.v.dot(p - l.u) / l.v.norm());
}

Line Bisector(const vec &a, const vec &b) {
  return {(a + b) * 0.5, (b - a).perp()};
}

Line Bisector(const vec &u, const vec &v1, const vec &v2) {
  vec v = v1 + v2 * sqrt(v1.norm() / v2.norm());
  return {u, fcmp(v.norm(), 0) ? v : v1.perp()};
}

tuple<int, vec> Intersection(const Line &l1, const Line &l2) {
  real delta = l1.v.det(-l2.v);
  return fcmp(delta, 0) ?
    make_tuple(1, l1.u + l1.v * ((l2.u - l1.u).det(-l2.v) / delta)) :
    make_tuple(0, vec());
}

tuple<int, vec, vec> Intersection(const Circle &c, const Line &l) {
  vec h = Foot(l, c.o);
  real delta = c.r * c.r - (h - c.o).norm();
  if (fcmp(delta, 0) == 0) {
    return make_tuple(1, h, vec());
  } else if (delta < 0) {
    return make_tuple(0, vec(), vec());
  } else {
    vec v = l.v * sqrt(delta / l.v.norm());
    return make_tuple(2, h + v, h - v);
  }
}

tuple<int, vec, vec> Intersection(const Circle &c1, const Circle &c2) {
  real d2 = (c1.o - c2.o).norm(), d = sqrt(d2);
  int delta = fcmp(c1.r + c2.r + d, max(max(c1.r, c2.r), d) * 2);
  if (delta == 0) {
    return make_tuple(1, c1.o + (c2.o - c1.o) * (c1.r / d), vec());
  } else if (delta < 0) {
    return make_tuple(0, vec(), vec());
  } else {
    real cosa = (c1.r * c1.r - c2.r * c2.r + d2) / (2 * c1.r * d);
    real sina = sqrt(1 - cosa * cosa);
    vec v = (c2.o - c1.o) * (c1.r / d);
    return make_tuple(2, c1.o + v * (vec){cosa, sina},
                      c1.o + v * (vec){cosa, -sina});
  }
}

const int maxn = 1000;

struct vec3 {
  real x, y, z;
  vec3 operator + (const vec3 &b) const { return {x + b.x, y + b.y, z + b.z}; }
  vec3 operator + (void) const { return {x, y, z}; }
  vec3 operator - (const vec3 &b) const { return {x - b.x, y - b.y, z - b.z}; }
  vec3 operator - (void) const { return {-x, -y, -z}; }
  vec3 operator * (real b) const { return {x * b, y * b, z * b}; }
  vec3 operator / (real b) const { return {x / b, y / b, z / b}; }
  real dot(const vec3 &b) const { return x * b.x + y * b.y + z * b.z; }
  real norm(void) const { return x * x + y * y + z * z; }
  real len(void) const { return sqrt(norm()); }
  real angle_xy(void) const { return atan2(y, x); }
  real angle_xz(void) const { return atan2(z, x); }
  vec3 unit(void) const { return *this / len(); }
};

int n;
real alpha;
vec3 point[maxn];

vec3 RotateXY(const vec3 &a, real b) {
  real sinb = sin(b), cosb = cos(b);
  return {a.x * cosb - a.y * sinb, a.x * sinb + a.y * cosb, a.z};
}

vec3 RotateXZ(const vec3 &a, real b) {
  real sinb = sin(b), cosb = cos(b);
  return {a.x * cosb - a.z * sinb, a.y, a.x * sinb + a.z * cosb};
}

int cnt_event;

struct Event {
  real time;
  int delta;
  bool operator < (const Event &b) const {
    return fcmp(time, b.time) ? time < b.time : delta > b.delta;
  }
} ev[maxn * 2];

bool InShape(const vec3 &u) {
  real x = RotateXY(u, -u.angle_xy()).angle_xz();
  return fcmp(x, pi / 2 - alpha) >= 0 && fcmp(x, pi / 2 + alpha) <= 0;
}

real key;

bool InShape2(const vec3 &u) {
  if (u.z < 0) return false;
  return u.z * u.z >= key * (u.x * u.x + u.y * u.y);
}

bool CalcInter(const vec3 &o, real r, real &ans) {
  if (fcmp(r, 0) == 0) {
    return false;
  }
  vec3 v1 = RotateXZ({r, 0, 0}, -alpha);
  vec3 v2 = RotateXZ({0, r, 0}, -alpha);
  if (!InShape(o - v1)) {
    return false;
  }
  int binary_repeat = 20;
  real low = 0, high = pi;
  while (binary_repeat--) {
    real mid = (low + high) * 0.5;
    vec3 u = o + v1 * cos(mid) + v2 * sin(mid);
    if (InShape2(u)) {
      high = mid;
    } else {
      low = mid;
    }
  }
  ans = low;
  return true;
}

real Adjust(real x) {
  while (fcmp(x, 2 * pi) >= 0) {
    x -= 2 * pi;
  }
  while (fcmp(x, 0) < 0) {
    x += 2 * pi;
  }
  return x;
}

int Solve(vec3 ctr) {
  real anxy = -ctr.angle_xy();
  ctr = RotateXY(ctr, anxy);
  real anxz = (pi / 2 - alpha) - ctr.angle_xz();
  ctr = RotateXZ(ctr, anxz);
  cnt_event = 0;
  int init_value = 0;

  for (int i = 0; i < n; ++i) {
    vec3 u = RotateXZ(RotateXY(point[i], anxy), anxz);
    vec3 o = ctr * (ctr.dot(u) / ctr.norm());
    vec3 ou_ = RotateXZ(u - o, alpha);
    vec ou = {ou_.x, ou_.y};
    real init_angle = ou.angle();

    if (InShape(u)) {
      ++init_value;
    }
    real touch_angle;
    if (CalcInter(o, ou.len(), touch_angle)) {
      ev[cnt_event++] = {Adjust(touch_angle - init_angle), 1};
      ev[cnt_event++] = {Adjust(-touch_angle - init_angle), -1};
    }
  }

  sort(ev, ev + cnt_event);
  int ans = 0;
  for (int i = 0; i < cnt_event; ++i) {
    init_value += ev[i].delta;
    ans = max(ans, init_value);
  }
  return ans;
}

int main(void) {
  int t;
  scanf("%d", &t);
  for (int id = 0; id < t; ++id) {
    scanf("%d%lf", &n, &alpha);
    alpha *= pi / 180;
    key = tan(pi / 2 - alpha);
    key *= key;
    int x0, y0, z0;
    scanf("%d%d%d", &x0, &y0, &z0);
    for (int i = 0; i < n; ++i) {
      int x, y;
      scanf("%d%d", &x, &y);
      x -= x0;
      y -= y0;
      point[i] = {(real)x, (real)y, (real)z0};
    }
    int ans = 1;
    for (int i = 0; i < n; ++i) {
      ans = max(ans, Solve(point[i]));
    }
    printf("Case #%d: %d\n", id + 1, ans);
  }
  return 0;
}

View Code

F - 缺失的数据范围

HDU - 6288

题意：给你a，b，k，求知足公式n^a*(⌈log2n⌉)^b<=k,的n的最大值。

思路：二分n，向上取整能够先预处理出2^62，而后直接循环找到b的底数j。要注意精度控制。

#include<iostream>
#include<stdlib.h>
#include<stdio.h>
#include<string.h>
#include<string>
#include<math.h>
#include<algorithm>
#include<queue>
#include<stack>
#include<vector>
#include<map>
#include<set>
#include<bitset>
#define INF 0x3f3f3f3f//3f3f3f3f
typedef long long ll;
using namespace std;
ll a,b,k;
ll s[100]={1};
int check(ll n)
{
    int j=0;
    for(j=0;j<=62;j++)
        if(n<=s[j])break;
    long double t=k;
    for(int i=0;i<b;i++)
    {
        t=t/(long double)j;
        if(t<1.0)return 0;
    }
    for(int i=0;i<a;i++)
    {
        t=t/(long double)n;
        if(t<1.0)return 0;
    }
    return 1;
}
int main()
{
    int ca;
    scanf("%d",&ca);
    for(int i=1;i<=62;i++)
    {
        s[i]=ll(1ll<<i);
    }
    while(ca--)
    {
      scanf("%lld%lld%lld",&a,&b,&k);
      ll l=0,r=k,mid;
      ll ans=0;
      while(r-l>1)
      {
          mid=(l+r)/2;
          if(check(mid))
          {
             l=mid;
          }
          else r=mid-1;
      }
      if(check(r))printf("%lld\n",r);
      else printf("%lld\n",l);
    }
    return 0;
}

View Code

G - Triangle

HDU - 5914

题意：给你1～n的木棍，问你最少取走几根能使剩下的木棍不能构成三角形

思路：签到题。首先，由于给定的n范围小，因此能够直接暴力。而后，它是一道找规律的题，为了达到取走的木棍数最少，因此尽量的取最大的。例举出来后，会发现剩下的棍子是编号是个斐波那契数列。

#include<iostream>
#include<algorithm>
#include<cstdio>
#include<cstring>
#include<cmath>
#include<queue>
#include<set>
#include<map>
#include<string>
#include<vector>
#include<ctime>
#include<stack>
using namespace std;
#define inf 0x3f3f3f3f
#define mm(a,b) memset(a,b,sizeof(a))
#define ll long long
#define MAXN 401000
#define mod ((int)1e9+7)
map<pair<int,int>,int> ma;
int main(){
    int a[10]={1,2,3,5,8,13,21};
    int t;
    scanf("%d",&t);
    int test=1;
    while(t--){
        int n;
        scanf("%d",&n);
        int ans=0;
        for(int i=0;i<=6;i++){
            if(a[i]<=n)
                ans++;
        }
        printf("Case #%d: %d\n",test++,n-ans);
    }
}

View Code

H - Machine

ZOJ - 3805

题意：有n个机器，每一个机器有两个输入口输入原料（上和右）和一个输出口输出产物（下），上一个机器的产物能够做为下一个机器的原料，且上一个机器的编号必定要大于下一个机器的编号。两个机器之间能够用'L'型和'I'型的管子相连，问你全部的机器连起来，最小的宽度是多少

思路：一个父节点的宽度就等于Max（上输入口子节点的宽度，右输入口子节点的宽度+1），所以，尽量的把宽度大的子节点链接在该节点的上输入口。

递归存入每一个节点的宽度，就能够获得根节点的宽度

#include <iostream>
#include <algorithm>
#include <cstring>
#include <string>
#include <vector>
#include <map>
#include <set>
#include <cstdio>
#include <cmath>
#include <stack>
#include <cstdlib>
using namespace std;
vector <int> ve[10010];
int dp[10000];
void dfs(int x){
    int len=ve[x].size();
    if(len==0)//若是其没有子节点
        dp[x]=1;//则宽度只须要记录它自己所占的
    else if(len==1){//若是只有一个
        dfs(ve[x][0]);
        dp[x]=dp[ve[x][0]];//该节点宽度为其子节点宽度（即放该节点的上面）
    }
    else{//最多就两个子节点
        int a,b;
        dfs(ve[x][0]);
        dfs(ve[x][1]);
        a=dp[ve[x][0]];
        b=dp[ve[x][1]];
        if(a==b){//若是两个子节点的宽度相等，那么该节点宽度为其中一个放在该节点右边的子节点的宽度+其自己所占的
            dp[x]=a+1;
        }
        else{//就把宽度值更大的放在该节点的上面，小的放该节点的右边。该节点的宽度即宽度值更大的子节点的宽度
            dp[x]=max(a,b);
        }
    }
}
int main()
{
    int n;
    while(~scanf("%d",&n)){
        for(int i=0;i<=n;i++)
            ve[i].clear();
        for(int i=2;i<=n;i++){
            int a;
            scanf("%d",&a);
            ve[a].push_back(i);//存该节点的子节点
        }
        dfs(1);
        printf("%d\n",dp[1]);
    }
}

View Code

I - Nastya Is Buying Lunch

CodeForces - 1136D

题意：给你一个大小为n的排列好的数组，m对二元组（x,y），若是x在y前面且x和y相邻，则可使x和y交换位置，问你最后一数最多能往前移动几步

思路：模拟交换过程。若是最后一个数能往前移，前面一定会有一个数和它有对应的二元组，所以找到那个区间，再模拟交换过程，查看是否能前移。

#include<iostream>
#include<algorithm>
#include<cstdio>
#include<cstring>
#include<cmath>
#include<queue>
#include<set>
#include<map>
#include<string>
#include<vector>
#include<ctime>
#include<stack>
using namespace std;
#define inf 0x3f3f3f3f
#define mm(a,b) memset(a,b,sizeof(a))
#define ll long long
#define MAXN 401000
#define mod ((int)1e9+7)
int a[MAXN];
map<pair<int,int>,int> ma;
int main()
{
    int n,m;
    scanf("%d %d",&n,&m);
    for(int i=0;i<n;i++)
        scanf("%d",&a[i]);
    for(int i=0;i<m;i++){
        int u,v;
        scanf("%d %d",&u,&v);
        ma[make_pair(u,v)]=1;//标记全部能交换的二元组
    }
    int last=n-1;
    for(int i=n-2;i>=0;i--){//从倒数第二个数开始往前遍历
        if(ma[make_pair(a[i],a[last])]){//若是存在一个数能与最后一个数交换，则模拟交换区间内的元素
            int j;
            for(j=i;j<last;j++){
                if(ma[make_pair(a[j],a[j+1])]){
                    swap(a[j],a[j+1]);
                }
                else
                    break;
            }
            if(j==last){//每次移动成功的话，就把最后一个数向前移一位，避免继续遍历时遇到后面已经交换过的数。
                last--;
            }
        }
    }
    printf("%d\n",n-1-last);
}

View Code

J - Easy billiards

ZOJ - 3761

题意：给你n个球的坐标，球能够朝{ 上，下，左，右 }中有另外一个球的方向运动，并经过撞击另外一个球使本身停下，被撞击的球沿着这个方向继续运动，若是这个方向上没有其余的球，被撞击的球将消失。

求最后最少能剩下几个球，并输出他们撞击的方向

思路：将能够互相撞击的球构成一棵树，从而变成了森林，最少剩下的球的数量就是树的数量，能够经过并查集求数量。(不用并查集也能够，先dfs，用vector存下撞击路径便可)

输出路径能够经过dfs，每次撞击都先由子节点撞击父节点

 1 #include<iostream>
 2 #include<algorithm>
 3 #include<cstdio>
 4 #include<cstring>
 5 #include<cmath>
 6 #include<queue>
 7 #include<set>
 8 #include<map>
 9 #include<string>
10 #include<vector>
11 #include<ctime>
12 #include<stack>
13 using namespace std;
14 #define inf 0x3f3f3f3f
15 #define mm(a,b) memset(a,b,sizeof(a))
16 #define ll long long
17 #define MAXN 2010
18 #define MAXM 1000010
19 #define mod 998244353
20 int n, p[MAXN];
21 struct node {
22     int x, y;
23 }a[MAXN];
24 int find(int x) {
25     return p[x] == -1 ? x : p[x] = find(p[x]);
26 }
27 void join(int x, int y) {
28     int a = find(x), b = find(y);
29     if (a != b) {
30         p[a] = b;
31     }
32 }
33 int head[MAXN], v[MAXM], ne[MAXM];
34 int vis[MAXN];
35 int id;
36 void addEdge(int x, int y) {
37     v[++id] = y;
38     ne[id] = head[x];
39     head[x] = id;
40 }
41 
42 void dfs(int u, int fa) {
43     vis[u] = 1;
44     for (int i = head[u]; i != -1; i = ne[i])
45     {
46         int now = v[i];
47         if (!vis[now])
48             dfs(now, u);
49     }
50     if (fa != -1)
51     {
52         printf("(%d, %d) ", a[u].x, a[u].y);
53         if (a[fa].x == a[u].x)
54         {
55             if (a[u].y < a[fa].y)
56                 puts("UP");
57             else puts("DOWN");
58         }
59         else
60         {
61             if (a[u].x < a[fa].x) puts("RIGHT");
62             else puts("LEFT");
63         }
64     }
65 }
66 
67 int main() {
68     while (~scanf("%d", &n))
69     {
70         mm(p, -1);
71         mm(head, -1);
72         mm(vis, 0);
73         id = 0;
74         for (int i = 0; i < n; ++i)
75             scanf("%d%d", &a[i].x, &a[i].y);
76         for (int i = 0; i < n; ++i)
77         {
78             for (int j = i + 1; j < n; ++j)
79             {
80                 if (a[i].x == a[j].x || a[i].y == a[j].y)
81                 {
82                     addEdge(i, j);
83                     addEdge(j, i);
84                     join(i, j);
85                 }
86             }
87         }
88         //计算连通块数量
89         int ans = 0;
90         for (int i = 0; i < n; ++i)
91             if (p[i] == -1) ans++;
92         printf("%d\n", ans);
93         for (int i = 0; i < n; ++i)
94         {
95             if (p[i] == -1) dfs(i, -1);
96         }
97     }
98 }

View Code

K - What Kind of Friends Are You?

ZOJ - 3960

题意：有q个问题和n个询问，告诉你第i个问题那些人能够回答（1<=i<=q）,而后第j个询问告诉你这我的能回答哪些问题，若是你能经过他回答的问题猜出他是谁，就输出他的名字，不然输出"Let's go to the 　library!!"

思路：经过二进制保存每一个人回答的问题，若是x能回答第i个问题，sum[x]+=1<<i

 1 #include<iostream>
 2 #include<algorithm>
 3 #include<cstdio>
 4 #include<cstring>
 5 #include<cmath>
 6 #include<queue>
 7 #include<set>
 8 #include<map>
 9 #include<string>
10 #include<vector>
11 #include<ctime>
12 #include<stack>
13 using namespace std;
14 #define inf 0x3f3f3f3f
15 #define mm(a,b) memset(a,b,sizeof(a))
16 #define ll long long
17 #define MAXN 2010
18 #define MAXM 1000010
19 int n, q;
20 map<string, int>m;
21 map<int, string>ans;
22 
23 int main()
24 {
25     int t;
26     int k, x;
27     string s;
28     scanf("%d", &t);
29     map<string, int>::iterator it;
30     while (t--)
31     {
32         m.clear();
33         ans.clear();
34         scanf("%d%d", &n, &q);
35         scanf("%d", &k);
36         for (int i = 0; i < k; ++i)
37         {
38             getchar();
39             cin >> s;
40             m[s] = 0;
41         }
42         for (int i = 0; i < q; ++i)
43         {
44             scanf("%d", &k);
45             while (k--)
46             {
47                 getchar();
48                 cin >> s;
49                 m[s] += 1 << i;
50             }
51         }
52         for (it = m.begin(); it != m.end(); it++)
53         {
54             if (ans.count(it->second))
55                 ans[it->second] = "Let's go to the library!!";
56             else
57                 ans[it->second] = it->first;
58         }
59         while (n--)
60         {
61             x = 0;
62             for (int i = 0; i < q; ++i)
63             {
64                 scanf("%d", &k);
65                 if(k) x += 1 << i;
66             }
67             if (ans.count(x))
68                 cout << ans[x] << endl;
69             else
70                 cout << "Let's go to the library!!\n";
71         }
72     }
73 }

View Code

L - Skyscrapers

CodeForces - 1137A

题意：对于两条交叉的街道，能够改变街道上每一个房子的高度，可是要维持同一条街道上房子之间的高矮性，即比他高的仍是比他高，比他矮的仍是比他矮，求这两条交叉的街道上更改高度后最高的房子的高度。给你n*m条交叉的街道，对于每一个交叉点求出这两条交叉的街道上更改高度后最高的房子的高度。

思路：ans[i][j] = 1 + max(i街道上比交叉点矮的不一样高度房子数，j街道上比交叉点矮的不一样高度房子数)+max(i街道上比交叉点高的不一样高度房子数，j街道上比交叉点高的不一样高度房子数)

 1 #include<iostream>
 2 #include<algorithm>
 3 #include<cstdio>
 4 #include<cstring>
 5 #include<cmath>
 6 #include<queue>
 7 #include<set>
 8 #include<map>
 9 #include<string>
10 #include<vector>
11 #include<ctime>
12 #include<stack>
13 using namespace std;
14 #define inf 0x3f3f3f3f
15 #define mm(a,b) memset(a,b,sizeof(a))
16 #define ll long long
17 #define MAXN 1010
18 #define mod 998244353
19 int n, a[MAXN][MAXN], m;
20 int ma1[MAXN][MAXN], mi1[MAXN][MAXN];
21 int ma2[MAXN][MAXN], mi2[MAXN][MAXN];
22 vector<int>v;
23 int main()
24 {
25     scanf("%d%d", &n, &m);
26     for (int i = 0; i < n; ++i)
27     {
28         for (int j = 0; j < m; ++j)
29             scanf("%d", &a[i][j]);
30     }
31     for (int i = 0; i < n; ++i)
32     {
33         v.clear();
34         for (int j = 0; j < m; ++j)
35             v.push_back(a[i][j]);
36         sort(v.begin(), v.end());
37         int end = unique(v.begin(), v.end()) - v.begin();
38         for (int j = 0; j < m; ++j)
39         {
40             mi1[i][j] = (int)(lower_bound(v.begin(), v.begin() + end, a[i][j]) - v.begin());
41             ma1[i][j] = end - mi1[i][j] - 1;
42         }
43     }
44     for (int i = 0; i < m; ++i)
45     {
46         v.clear();
47         for (int j = 0; j < n; ++j)
48             v.push_back(a[j][i]);
49         sort(v.begin(), v.end());
50         int end = unique(v.begin(), v.end()) - v.begin();
51         for (int j = 0; j < n; ++j)
52         {
53             mi2[j][i] = (int)(lower_bound(v.begin(), v.begin() + end, a[j][i]) - v.begin());
54             ma2[j][i] = end - mi2[j][i] - 1;
55         }
56     }
57     for (int i = 0; i < n; ++i)
58     {
59         for (int j = 0; j < m; ++j)
60             printf("%d ", 1 + max(mi1[i][j], mi2[i][j]) + max(ma1[i][j], ma2[i][j]));
61         printf("\n");
62     }
63 }

View Code