pat1121-1131

最新推荐文章于 2021-09-09 08:59:40 发布
最新推荐文章于 2021-09-09 08:59:40 发布
阅读量417 收藏
点赞数
分类专栏： 浙大pat
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/basasuya/article/details/73250313
版权

1121

#include<cmath>
#include<map>
#include<iostream>
#include<cstring>
#include<cstdio>
#include<set>
#include<vector>
#include<queue>
#include<stack>
#include<algorithm>
using namespace std;
typedef long long ll;
const int N = 1e6+5;
const int INF = 0x3f3f3f3f;
#define MP(x, y) make_pair(x, y)

int pai[N];
int a[N];
int has[N];
int ord[N];
int main() {
  int n;
  while(~scanf("%d", &n)) {
    memset(pai, -1, sizeof(pai));
    for(int i = 0; i < n; ++i) {
      int a, b; scanf("%d%d", &a, &b);
      pai[a] = b; pai[b] = a;
    }

    int m; scanf("%d", &m);
    for(int i = 0; i < m; ++i) {
      scanf("%d", &a[i]);
      has[a[i]] ++; if(pai[a[i]] != -1) has[pai[a[i]]] ++;
    }
    int tot = 0;
    for(int i = 0; i < m; ++i) {
      if(has[a[i]] == 1) {
        ord[tot ++] = a[i];
      }
    }

    sort(ord, ord + tot);
    printf("%d\n", tot);
    for(int i = 0; i < tot; ++i) {
      if(i) printf(" ");
      printf("%05d", ord[i]);
    }
    if(tot) printf("\n");
  }
  return 0;
}

1122 我把爆搜都写完了，才发现这题的圈顺序是给定的，我爆搜就不删了

#include<cmath>
#include<map>
#include<iostream>
#include<cstring>
#include<cstdio>
#include<set>
#include<vector>
#include<queue>
#include<stack>
#include<algorithm>
using namespace std;
typedef long long ll;
const int N = 205;
const int INF = 0x3f3f3f3f;
#define MP(x, y) make_pair(x, y)

struct Node{
  int to, nx;
}E[N*N*2];
int mp[N][N];
int head[N], tot;
void add(int fr, int to) {
  E[tot].to = to; E[tot].nx = head[fr]; head[fr] = tot ++;
}
set<int> st;
int suc;
void dfs(int l, int r) {
  printf("%d %d\n", l, r);
  if(suc) return;
  if(st.size() == 0) {
    if(mp[l][r]) suc = 1;
    return;
  } 
  if(st.size() == 1) {
    int tt = *st.begin();
    if(mp[l][tt] && mp[r][tt]) {
      suc = 1;
    } 
    return;
  }


  vector<int> ch1; vector<int> ch2;
  for(int i = head[l]; ~i; i = E[i].nx) {
    if(st.find(E[i].to) != st.end()) {
      ch1.push_back(E[i].to);
    }
  }
  if(l == r) {
    for(int i = 0; i < ch1.size() && !suc; ++i) {
      for(int j = i+1; j < ch1.size() && !suc; ++j) {
        st.erase(ch1[i]); st.erase(ch1[j]);
        dfs(ch1[i], ch1[j]);
        st.insert(ch1[i]); st.insert(ch1[j]);
      }
    }
    return;
  }
  for(int i = head[r]; ~i; i = E[i].nx) {
    if(st.find(E[i].to) != st.end()) {
      ch2.push_back(E[i].to);
    }
  }

  for(int i = 0; i < ch1.size() && !suc; ++i) {
    for(int j = 0; j < ch2.size() && !suc; ++j) {
      if(ch1[i] != ch2[j]) {
        st.erase(ch1[i]); st.erase(ch2[j]);
        dfs(ch1[i], ch2[j]);
        st.insert(ch1[i]); st.insert(ch2[j]);
      }
    }
  }

}
int main() {
  int n,m;
  while(~scanf("%d %d", &n, &m)) {
    memset(head, -1, sizeof(head));
    tot = 0;

    for(int i = 0; i < m; ++i) {
      int a, b; scanf("%d %d", &a, &b);
      add(a, b); add(b, a);
      mp[a][b] = mp[b][a] = 1;
    }


    int k; scanf("%d", &k);
    while(k --) {
      int a; scanf("%d", &a);
      int fl = 1;
      st.clear();
      int pre = -1;
      int St = -1;

      for(int i = 0; i < a; ++i) {
        int b; scanf("%d", &b);
        if(St == -1) St = b;
        if(st.find(b) != st.end() && i != a-1) fl = 0;
        if(i == a-1 && St != b) fl = 0;
        if(~pre && !mp[b][pre]) fl = 0;
        pre = b;
        st.insert(b);
      }

    //  int tt = *st.begin(); st.erase(tt);
    //  suc = 0;
    //  dfs(tt, tt);

      if(fl && a > 4) printf("YES\n");
      else printf("NO\n");
    }
  }
  return 0;
}

1123 和之前一道avl类似

#include<cmath>
#include<map>
#include<iostream>
#include<cstring>
#include<cstdio>
#include<set>
#include<vector>
#include<queue>
#include<algorithm>
using namespace std;
typedef long long ll;
const int N = 25;
const int INF = 0x3f3f3f3f;
#define MP(x, y) make_pair(x, y)

int root;
int num[N];
int L[N], R[N], fa[N];
int n;

void insert(int x, int tag) {
  //  printf("tag: %d\n", x);
  if(!root) {
    root = tag; fa[tag] = tag; return; 
  }
  if(num[x] > num[tag]) {
    if(!L[x])  L[x] = tag, fa[tag] = x;
    else insert(L[x], tag);
  }else {
    if(!R[x])  R[x] = tag, fa[tag] = x;
    else insert(R[x], tag);
  }
}


struct Node{
  int po, val;
  Node(int a=0, int b=0):po(a), val(b){}
}E[10];
int cmp(Node a,Node b) {
  return a.val < b.val;
}

void LL(int x) {
  //  printf("LL\n");
  int fart = fa[fa[x]];
  int t1 = x; int t2 = R[x]; int t3 = fa[x];
  fa[t1] = 0; fa[t2] = 0; fa[t3] = 0;
  R[t1] = t3; fa[t3] = t1;
  L[t3] = t2; fa[t2] = t3;

  if(t3 == root) {
    root = t1; fa[t1] = t1;
  }else if(L[fart] == t3) {
    L[fart] = t1; fa[t1] = fart;
  }else R[fart] = t1, fa[t1] = fart;
}
void RR(int x) {
  //  printf("RR\n");
  int fart = fa[fa[x]];
  int t1 = x; int t2 = L[x]; int t3 = fa[x];
  fa[t1] = 0; fa[t2] = 0; fa[t3] = 0;
  L[t1] = t3; fa[t3] = t1;
  R[t3] = t2; fa[t2] = t3;

  if(t3 == root) {
    root = t1; fa[t1] = t1;
  }else if(L[fart] == t3) {
    L[fart] = t1; fa[t1] = fart;
  }else R[fart] = t1, fa[t1] = fart;
}
void LR(int x, int tag) {
  //  printf("LR\n");

  int fart = fa[fa[x]];
  int t1 = x; int t2 = R[x]; int t3 = fa[x];
  int a1 = L[t2]; int a2 = R[t2];

  fa[t1] = 0; fa[t2] = 0; fa[t3] = 0;
  R[t1] = 0; L[t3] = 0;
  L[t2] = t1; fa[t1] = t2;
  R[t2] = t3; fa[t3] = t2;
  if(t3 == root) {
    root = t2; fa[t2] = t2;
  }else if(L[fart] == t3) {
    L[fart] = t2; fa[t2] = fart;
  }else {
    R[fart] = t2; fa[t2] = fart;
  }

  if(a1) insert(root, a1);
  if(a2) insert(root, a2);
}
void RL(int x, int tag) {
  //  printf("RL\n");
  int fart = fa[fa[x]];
  int t1 = x; int t2 = L[x]; int t3 = fa[x];
  int a1 = L[t2]; int a2 = R[t2];

  L[t1] = 0; R[t3] = 0;
  fa[t1] = 0; fa[t2] = 0; fa[t3] = 0;
  L[t2] = t3; fa[t3] = t2;
  R[t2] = t1; fa[t1] = t2;
  //   printf("hh %d %d %d\n", num[t1], num[t2], num[t3]);
  if(t3 == root) {
    root = t2; fa[t2] = t2;
  }else if(L[fart] == t3) {
    L[fart] = t2; fa[t2] = fart;
  }else {
    R[fart] = t2; fa[t2] = fart;
  }
  //  printf("hh %d %d", fart, R[fart]);
  if(a1) insert(root, a1);
  if(a2) insert(root, a2);
}
void fix(int x) {
  int rt = fa[fa[x]]; int fart = fa[rt];
  if( (L[rt]==0) + (R[rt]==0) == 1) {
    int tot = 0;
    for(int i = 0, tt = x; i < 3; ++i) {
      E[tot++] = Node(tt, num[tt]); 
      tt = fa[tt];
    }  
    sort(E, E+tot, cmp);
    L[E[1].po] = E[0].po; fa[E[0].po] = E[1].po;  
    R[E[1].po] = E[2].po; fa[E[2].po] = E[1].po;
    L[E[0].po] = 0; R[E[0].po] = 0;
    L[E[2].po] = 0; R[E[2].po] = 0;

    if(root == rt) {
      root = E[1].po; fa[root] = root;
    }else if(L[fart] == rt) {
      L[fart] = E[1].po; fa[E[1].po] = fart;
    }else {
      R[fart] = E[1].po; fa[E[1].po] = fart;
    }
  }else {
    //  printf("%d %d %d\n", x, rt, fa[rt]);
    if     (L[fa[rt]] == rt && L[rt] == fa[x] ) LL(rt);
    else if(R[fa[rt]] == rt && R[rt] == fa[x] ) RR(rt);
    else if(L[fa[rt]] == rt && R[rt] == fa[x] ) LR(rt, x);
    else if(R[fa[rt]] == rt && L[rt] == fa[x] ) RL(rt, x);
  }
}
void test(int x, int pre) {
  printf("%d from %d\n", x, pre);
  if(L[x]) test(L[x], x);
  if(R[x]) test(R[x], x);
}

int height[N]; int tag;
void dfs(int x) {
  int t1 = 0, t2 = 0;
  if(L[x]) dfs(L[x]), t1 = height[L[x]];
  if(R[x]) dfs(R[x]), t2 = height[R[x]];
  height[x] = max(t1, t2)+1;
  if( abs(t1- t2) > 1  && !tag) tag = x;
}
void solve(int x) {
  //  printf("do %d\n", x);
  memset(height, 0, sizeof(height));
  tag = 0;
  dfs(root);
  if(tag) {
    int t1 = tag;
    if(height[L[t1]] > height[R[t1]]) t1 = L[t1];
    else t1 = R[t1];

    if(height[L[t1]] > height[R[t1]]) t1 = L[t1];
    else t1 = R[t1];

    if(height[L[t1]] > height[R[t1]]) t1 = L[t1];
    else if(height[L[t1]] < height[R[t1]]) t1 = R[t1];

    //  printf("%d %d\n", tag, t1);
    fix(t1);
  }
  //  test(root, root);
  //  printf("\n");
}
void bfs(int x) {
  int all = 0;
  queue<int> Q;
  Q.push(x);
  while(Q.front() != 0) {
    int po = Q.front(); Q.pop();
    all ++;
    Q.push(L[po]); Q.push(R[po]);
  }
  while(!Q.empty()) Q.pop();
  Q.push(x);
  int nn = 0;
  while(!Q.empty()) {
    int po = Q.front(); Q.pop();
    if(!nn) nn = 1; else printf(" ");
    printf("%d", num[po]);
    if(L[po]) Q.push(L[po]);
    if(R[po]) Q.push(R[po]);
  }
  printf("\n");
  if(all == n) printf("YES\n");
  else printf("NO\n");

}
int main() {
  while(~scanf("%d", &n)) {
    root = 0;
    memset(fa, 0, sizeof(fa));
    memset(L, 0, sizeof(L));
    memset(R, 0, sizeof(R));

    for(int i = 1; i <= n; ++i) {
      scanf("%d", &num[i]);
      insert(root, i);
      solve(i);
      //  fa[root] = root;
      //  check(root);
    }
  //  printf("hh\n");
    bfs(root);
  //  printf("%d\n", num[root]);
  }
  return 0;
}

1124

#include<cmath>
#include<map>
#include<iostream>
#include<cstring>
#include<cstdio>
#include<set>
#include<vector>
#include<queue>
#include<algorithm>
using namespace std;
typedef long long ll;
const int N = 25;
const int INF = 0x3f3f3f3f;
#define MP(x, y) make_pair(x, y)

map<string, int> mp;
int main() {
  int m, n, s;
  while(~scanf("%d %d %d", &m, &n, &s)) {
    int won = s;
    int all = 0;
    mp.clear();
    for(int i = 1, j = 1; i <= m; ++i) {
      char s[10]; scanf("%s", s);
      if(j == won) {
        if(mp.find(s) == mp.end()) printf("%s\n", s), won += n, all ++;
        else j --;
        mp[s] = 1;
      }
      j++;
    }
    if(!all) printf("Keep going...\n");
  }
  return 0;
}

1125 讲道理我没有读懂题之前 = =我以为在你们选几个组成不就行了，直接选两个最大的

#include<cmath>
#include<map>
#include<iostream>
#include<cstring>
#include<cstdio>
#include<set>
#include<vector>
#include<queue>
#include<algorithm>
using namespace std;
typedef long long ll;
const int N = 1e4+5;
const int INF = 0x3f3f3f3f;
#define MP(x, y) make_pair(x, y)

int a[N];
int main() {
  int n;
  while(~scanf("%d", &n)) {
    for(int i = 0; i < n; ++i) scanf("%d", &a[i]);
    sort(a, a + n);
    int ans = a[0];
    for(int i = 1; i < n; ++i) {
      ans = (ans + a[i]) / 2;
    }
    printf("%d\n", ans);
  }
  return 0;
}

1126需先判断下图的连通性

#include<cmath>
#include<map>
#include<iostream>
#include<cstring>
#include<cstdio>
#include<set>
#include<vector>
#include<queue>
#include<algorithm>
using namespace std;
typedef long long ll;
const int N = 505;
const int INF = 0x3f3f3f3f;
#define MP(x, y) make_pair(x, y)

struct Node{
  int to, nx;
}E[N*N*2];
int head[N], tot;
int vis[N];
void add(int fr, int to) {
  E[tot].to = to; E[tot].nx = head[fr]; head[fr] = tot ++;
}
void dfs(int x) {
  for(int i = head[x]; ~i; i = E[i].nx) {
    int to = E[i].to;
    if(!vis[to]) {
      vis[to] = 1;
      dfs(to);
    }
  }
}
int in[N];
int main() {
  int n, m;
  while(~scanf("%d %d", &n, &m)) {
    memset(in, 0, sizeof(in));
    memset(vis, 0, sizeof(vis));
    memset(head, -1, sizeof(head)); tot = 0;

    for(int i = 0; i < m; ++i) {
      int a, b; scanf("%d %d", &a, &b);
      add(a, b); add(b, a); 
      in[a] ++; in[b] ++;
    }
    vis[1] = 1; 
    dfs(1);

    int fl = 1;
    for(int i = 1; i <= n; ++i) {
      if(!vis[i]) {
        fl = 0; break;
      }
    }

    int odd = 0; int even = 0;
    for(int i = 1; i <= n; ++i) {
      if(in[i] % 2 == 0) even ++;
      else odd ++;
    }

    for(int i = 1; i <= n; ++i) {
      if(i != 1) printf(" ");
      printf("%d", in[i]);
    } printf("\n");

    if(odd == 0 && fl) printf("Eulerian\n");
    else if(odd == 2 && fl) printf("Semi-Eulerian\n");
    else printf("Non-Eulerian\n");


  }
  return 0;
}

1127 

#include<cmath>
#include<map>
#include<iostream>
#include<cstring>
#include<cstdio>
#include<set>
#include<vector>
#include<queue>
#include<algorithm>
using namespace std;
typedef long long ll;
const int N = 35;
const int INF = 0x3f3f3f3f;
#define MP(x, y) make_pair(x, y)

int in[N];
int post[N];
map<int, int> L;
map<int, int> R;

int solve(int LL, int RR, int l, int r) {
  if(l > r) return 0;
     else if(l == r) return post[l];

  int tag = post[r];
  int po = 0;
  for(int i = LL; i <= RR; ++i) {
    if(in[i] == tag) {
      po = i; break;
    }
  }
  int _po = l + (po-1-LL);

  L[tag] = solve(LL, po-1, l, _po);
     R[tag] = solve(po+1, RR, _po+1, r-1);

  return tag;
}
void bfs(int x) {
  queue<int> Q;
  Q.push(x);
  int fl = 1;

  while(!Q.empty()) {
    vector<int> vc;
    int ed = Q.size();
    for(int i = 0; i < ed; ++i) {
      int po = Q.front(); Q.pop();
      vc.push_back(po);
      if(L[po]) Q.push(L[po]);
      if(R[po]) Q.push(R[po]);
    }

    if(fl) for(int i = vc.size()-1; i >= 0; --i) {
      if(vc[i] != x) printf(" ");
      printf("%d", vc[i]);
    }else for(int i = 0; i < vc.size(); ++i) {
      if(vc[i] != x) printf(" ");
      printf("%d", vc[i]);
    }
    fl ^= 1;
  }
  printf("\n");
}
int main() {
  int n;
  while(~scanf("%d", &n)) {

    for(int i = 1; i <= n; ++i) {
      scanf("%d", &in[i]);
    }


    for(int i = 1; i <= n; ++i) scanf("%d", &post[i]);

    int root = solve(1, n, 1, n);

    bfs(root);  
  }
  return 0;
}

1128 

#include<cmath>
#include<map>
#include<iostream>
#include<cstring>
#include<cstdio>
#include<set>
#include<vector>
#include<queue>
#include<algorithm>
using namespace std;
typedef long long ll;
const int N = 1005;
const int INF = 0x3f3f3f3f;
#define MP(x, y) make_pair(x, y)

int dia1[N*2];
int row[N];
int dia2[N*2];

int main() {
  int k;
  while(~scanf("%d", &k)) {

    for(int i = 1; i <= k; ++i) {
      int a; scanf("%d", &a);
      int fl = 1;

      for(int j = 1; j <= a; ++j) {
        int b; scanf("%d", &b);
        int t1 = b; int t2 = b-j + a; int t3 = b+j;
        if(row[t1] == i|| dia1[t2] == i || dia2[t3] == i ) fl = 0;

        row[t1] = i; dia1[t2] = i; dia2[t3] = i;
      }  

      if(fl) printf("YES\n");
      else printf("NO\n");
    }

  }
  return 0;
}

1129

#include<cmath>
#include<map>
#include<iostream>
#include<cstring>
#include<cstdio>
#include<set>
#include<vector>
#include<queue>
#include<algorithm>
using namespace std;
typedef long long ll;
const int N = 5e4+5;
const int INF = 0x3f3f3f3f;
#define MP(x, y) make_pair(x, y)

int has[N];
int a[N];
struct Node{
  int nu, po;
  Node(int a=0, int b=0):nu(a), po(b) {}
  bool operator <(const Node &T) const  {
    if(nu != T.nu) return nu > T.nu;
    else return po < T.po;
  }
};
set<Node> st;
set<Node> ::iterator it;

int main() {
  int n, k;
  while(~scanf("%d %d", &n, &k)) {
    st.clear();
    memset(has, 0, sizeof(has));

    for(int i = 1; i <= n; ++i) scanf("%d", &a[i]);

    has[a[1]] ++;
    st.insert(Node(has[a[1]], a[1]));

    for(int i = 2; i <= n; ++i) {
      printf("%d: ", a[i]);
      int cnt = 0;
      for(it = st.begin(); it != st.end(); ++it) {
        if(it != st.begin()) printf(" ");
        printf("%d", (*it).po);
        cnt ++;
        if(cnt >= k) break;
      }
      printf("\n");


      has[a[i]] ++;

      it = st.find(Node(has[a[i]]-1, a[i]) );
      if( it != st.end() ) st.erase(it), st.insert(Node(has[a[i]], a[i]));
      else {
        st.insert(Node(has[a[i]], a[i]));
        if(st.size() > k) st.erase(--st.end());
      }

    }  
  }
  return 0;
}

1030

#include<cmath>
#include<map>
#include<iostream>
#include<cstring>
#include<cstdio>
#include<set>
#include<vector>
#include<queue>
#include<algorithm>
using namespace std;
typedef long long ll;
const int N = 25;
const int INF = 0x3f3f3f3f;
#define MP(x, y) make_pair(x, y)

char num[N][15];
int dep[N];
int root;
int L[N], R[N];

void dfs(int x) {
  if(x != root && L[x] + R[x]) printf("(");
  if(L[x]) dfs(L[x]);
  printf("%s", num[x]);
  if(R[x]) dfs(R[x]);
  if(x != root && L[x] + R[x]) printf(")");
}
int main() {
  int n;
  while(~scanf("%d", &n)) {
    for(int i = 1; i <= n; ++i) {
      char b[10], c[10];
      scanf("%s %s %s", num[i], b, c);
      int tt;
      if(b[0] != '-') {
        sscanf(b, "%d", &tt);
        L[i] = tt, dep[tt] ++;
      }
      if(c[0] != '-') {
        sscanf(c, "%d", &tt);
        R[i] = tt; dep[tt] ++;
      }
    }
    for(int i = 1; i <= n; ++i) {
      if(!dep[i]) {
        root = i;
        dfs(i);
        break;
      }
    }

    printf("\n");


  }
  return 0;
}

1031 最后一题还是花了一点时间，简单来说就是最短路即可，但是中间处理还是有点难的

#include<cmath>
#include<map>
#include<iostream>
#include<cstring>
#include<cstdio>
#include<set>
#include<vector>
#include<queue>
#include<algorithm>
using namespace std;
typedef long long ll;
const int N = 105;
const int M = 1e5+5;

const int INF = 0x3f3f3f3f;
#define MP(x, y) make_pair(x, y)

map<int, int> nam;
map<int, int> ::iterator it;
int _nam[M];
vector<int> input[N];
int n; 
int tol;
struct Node{
  int nx, to, ty;
}E[M*10];
int head[M], tot;
void add(int fr, int to, int ty) {
  E[tot].to = to; E[tot].nx = head[fr]; E[tot].ty = ty; head[fr] = tot++;
}
struct Hode{
  int po, di, ti, ty;
  Hode(int a=0, int b=0, int c=0, int d=0):po(a), di(b), ti(c), ty(d) {}
  bool operator < (const Hode & T) const{
    if(di != T.di) return di > T.di;
    else return ti > T.ti;
  }
};
pair<int, int> pre[M]; int vis[M];
int dis[M], tim[M];
vector<pair<int, int> > ans;

void dfs(int x, int s) {
//  printf("%d %d\n", x, _nam[x]);
  if(x == s) {
    return ;
  }
  dfs(pre[x].first, s);
  ans.push_back(MP(x, pre[x].second));
}

void dij(int s, int t) {
//  printf("%d %d\n", s, t);
  for(int i = 1; i <= tol; ++i) {
    vis[i] = 0; dis[i] = INF; tim[i] = INF;
  }
  dis[s] = 0; tim[s] = 0;
  priority_queue<Hode> Q;
  Q.push(Hode(s, dis[s], tim[s], INF));
  while(!Q.empty()) {
    int po = Q.top().po; int ty = Q.top().ty; Q.pop();
    if(vis[po]) continue;
    vis[po] = 1;
    for(int i = head[po]; ~i; i = E[i].nx) {
      int to = E[i].to;
         int tt = ty != E[i].ty;  
      if(dis[to] > dis[po] + 1) {
        dis[to] = dis[po] + 1;
        tim[to] = tim[po] + tt;
        pre[to] = MP(po, E[i].ty);
        Q.push(Hode(to, dis[to], tim[to], E[i].ty));
      }else if(dis[to] == dis[po] + 1 && tim[to] > tim[po] + tt )  {
        tim[to] = tim[po] + tt;
        pre[to] = MP(po, E[i].ty);
        Q.push(Hode(to, dis[to], tim[to], E[i].ty));
      }
    }
  }
  ans.clear();
  dfs(t, s);
  printf("%d\n", dis[t]);
  int fr = s;
  ans.push_back(MP(INF, INF));
  for(int i = 1; i < ans.size(); ++i) {
    if(ans[i].second != ans[i-1].second) {
      printf("Take Line#%d from %04d to %04d.\n", ans[i-1].second, _nam[fr], _nam[ans[i-1].first]);
      fr = ans[i-1].first;
    }
  }
}

int main() {
  while(~scanf("%d", &n)) {
    memset(head, -1, sizeof(head)); tot = 0;

    for(int i = 1; i <= n; ++i) {
      int m; scanf("%d", &m);
      input[i].push_back(m);
      for(int j = 0; j < m; ++j) {
        int b; scanf("%d", &b);
        input[i].push_back(b);
        nam[b] ++;
      }
    }

    tol = 0;
    for(it = nam.begin(); it != nam.end(); ++it) {
      nam[it->first] = ++tol;
      _nam[tol] = it->first;
    }
    // for(int i = 1; i <= tol; ++i) printf("%d:%d ", _nam[i], nam[_nam[i]]); printf("\n");

    for(int i = 1; i <= n; ++i) {
      for(int j = 2; j < input[i].size(); ++j) {
        add(nam[input[i][j]], nam[input[i][j-1]], i); add(nam[input[i][j-1]], nam[input[i][j]], i);
      }
    }

    int m; scanf("%d", &m);
    while(m --) {
      int a, b; scanf("%d %d", &a, &b);
      dij(nam[a], nam[b]);
    }  
  }
  return 0;
}
basasuya
关注
专栏目录
PAT A1131 Subway Map (30 分) 图 dfs
HackingGate的博客
09-06 166
题目大意：给出一些地铁的线路和线路上地铁站的id，输出从起点到终点的经过地铁站最少的路径。如果这样的路径不止一条，输出换乘次数最少的路径。 无向有环图的最短路径，理论上可以用bfs做，但是因为还有换乘次数最少的限定条件，不是很方便。所以还是用dfs得到所有的路径，再判断是否是经过地铁站最少的，以及换乘次数最少的。 要注意以下几个要点： ① 在用dfs的时候要维护 visite...
宇宙无敌PAT-A不完全考纲
大美mixer的博客
02-07 998
    大家新年快乐！     最近一直有朋友问我“考研上机怎么准备？”、“马上找工作，想考PAT练练手”等...其实本来刚考完PAT的时候，我是想总结一下各个平台以及教程的所有题目合成一本模板教程。但是我想想吧，这样让大家太偷懒了，不利于大家的智力发展。还是建议大家自己先做一遍，然后对着答案改，然后形成自己的模板比较好（其实是我懒 /(T_T)/~~~）...
pat a 1131
blxl313的博客
02-06 156
一开始我的dfs是这样写的（两者对比的话对visit数组如何赋0有不同），这样写的错误原因是没有在深搜去其他路径时让出道路，类似于一条线走到黑了。想一想，用dijsktra会不会让我容易写一些。说到底我还是递归困难户。 #include <iostream> #include <vector> #include <cstring> #include <un...
PAT A1131
我好像在哪儿见过你
08-05 245
题目：https://pintia.cn/problem-sets/994805342720868352/problems/994805347523346432 这个题思路说不上很难，但是在考试时间的限制下真的是压力山大，十万条命接不起。本人用的两次DFS，一次找最短路径。第二次通过最少的换乘数找最佳路径。感觉比较难的点，是保存几号线以及中转站。别忽略地铁是双向的。该算法要剪枝，不然要超时。因为...
PAT 1131
Keep Fighting!
10-23 429
In the big cities, the subway systems always look so complex to the visitors. To give you some sense, the following figure shows the map of Beijing subway. Now you are supposed to help people with you...
PAT a1131
CSlerner的博客
08-02 337
目的：帮别人找到去目的地的最快的路径 输入： N <=100 线路条数 线路格式： M S[1] S[2] ...S[M] M <=100 线路上站点数 S[I] 站点的标号，4位数字，0000~9999 注意： 可以有环路，但是没有自循环 有些站可能是中转站，但是每个站最多连接不超过5条线路。 K <=10 查询数字 开始站点 目的站点 ...
PAT甲级
qq_42347617的博客
02-24 1278
编号 标题 题解 分类 备注 1001 A+B Format C++ 字符串处理 1002 A+B for Polynomials C++ 中级模拟+散列 多项式求和问题 1003 Emergency C++ 图 最短路径问题 1004 Counting Leaves C++ 树 树的遍历问题 1005 Spell It Right C++ 字符串处理 10...
PAT甲级分类
weixin_44414413的博客
03-19 913
PAT甲级题目分类 水题 1136、1139、1143、1148 字符串处理 1001、1005、1035、1061、1073、1077、1082、 1108、1140、1152 模拟 1002、1009、1017、1026、1042、1046、1065、 1105 查找元素 1006、1011、1036 动态规划 1007、...
pat-1131
江船夜雨听笛的博客
01-19 130
需二刷 注意一下输出格式！！！！！%04d这他娘的就是个坑！！！ #include<iostream> #include<vector> #include<unordered_map> using namespace std; vector<int> path,tempath,v[10009]; unordered_map<int,int> line; int anscnt,anstcnt, start,end1, visit[10009..
pat甲级题解目录
热门推荐
日沉云起的博客
12-12 1万+
编号 标题 题解 分类 备注 1001 A+B Format (20) C++ 字符串处理 1002 A+B for Polynomials (25) ...
pat A 1131
qq_40178140的博客
09-04 557
写了近90分钟才过，菜鸡如我 #include&lt;cstdio&gt; #include&lt;iostream&gt; #include&lt;vector&gt; #include&lt;set&gt; #include&lt;string&gt; #include&lt;sstream&gt; #include&lt;map&gt; #include&lt;algorithm
PAT A 1131(Subway map)
suiyuewushengly的博客
09-09 92
干了好久，参考柳神的代码，套用凡神的模板，终于写出了自己满意的代码，唉，还是太弱了，还得练习。 #include <bits/stdc++.h> using namespace std; const int maxn = 10010, INF = 0x3fffffff; int line[maxn][maxn]; vector<int> G[maxn]; bool vis[maxn]; int start,ed; int getTransfer(vector<int>
PAT A1131. Subway Map (30)
jackiewoo_的博客
03-08 384
Subway Map (30) 时间限制 400 ms 内存限制 65536 kB 代码长度限制 16000 B 判题程序 Standard 作者 CHEN, Yue In the big cities, the subway systems always look so complex to the visitors. To give you some sense, t...
PAT1131 Subway Map（DFS&&回溯）
SeasonJoe的博客
08-08 394
题意： 找出一条路线，使得对任何给定的起点和终点，可以找出中途经停站最少的路线；如果经停站一样多，则取需要换乘线路次数最少的路线 思路： 这题就是用dfs+回溯写，我回溯写错了，找到终点的地方回溯了一次，递归回去又回溯了一次，这样就回溯了两次，看别人代码写了一下，这题还有一个地方要注意的就是这个换乘线路，我一开始是很随意的看该点有几条分支，超过2条说明为节点，但实际上这题求的是换乘的次数，完...
PAT 1131. Subway Map (30) -甲级
柳婼 の blog
03-31 8057
1131. Subway Map (30) In the big cities, the subway systems always look so complex to the visitors. To give you some sense, the following figure shows the map of Beijing subway. Now you are supposed
pat-1121
江船夜雨听笛的博客
01-24 137
这种题先去找找规律，其中一个出现后另一个一定会怎么样 #include<iostream> #include<vector> #include<set> using namespace std; int main(){ int n,temp1,temp2,m; scanf("%d",&n); vector<int>cou(100000); for(int i=0;i<100000;i++){ cou[i]=-1; } .
PAT (Advanced Level) Practice python解法合集
qq_36936510的博客
01-07 990
1001 A+B Format 1002 A+B for Polynomials 1003 Emergency 1004 Counting Leaves 1005 Spell It Right 1006 Sign In and Sign Out 1007 Maximum Subsequence Sum 1008 Elevator 1009 Product of Polynomials 1010 R...
PAT【甲级】1131
qq_41375322的博客
04-21 153
题目链接：PAT【甲级】1131 题目简述：给定一个地铁路线，问从初始位置到终止位置的最短路径，如果有多个最短路径那么找到那条转线最少的路径。 #include<bits/stdc++.h> using namespace std; unordered_map<int, bool> vis; unordered_map<int, int> whichLine; vector<int> v[10000]; vector<pair<int,int&g
PAT甲级A1131 Subway Map (30分)--思路解析
qq_29006825的博客
05-01 227
1,题目就不自己打了 附链接A1131 2,基本思路 a，使用dfs遍历枚举得到题目要求的路径，存储于vector<int> path中。 b，将路径输出，输出时需注意对应格式。 3，本题的关键点 a，如何存储对应的图 由题，可知顶点0000-9999，用邻接矩阵必然空间不够。因此选择邻接表存储结构。如下： vector<int> edges[Maxn]; b，如...
PAT-A1131 Subway Map 题目内容及题解
BourbonWhiskey 的博客
02-11 900
In the big cities, the subway systems always look so complex to the visitors. To give you some sense, the following figure shows the map of Beijing subway. Now you are supposed to help people with you...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值