noip 2013 提高组 day1

1.转圈游戏:

 　　解析部分略，快速幂就可以过

Code:

#include<iostream>
#include<fstream>
using namespace std;
ifstream fin("circle.in");
ofstream fout("circle.out");
long long k;
long long n;
long long result;
long long x;
long long m;
long long _pow(int a, int pos){
    if(pos == 1) return a%n;
    long long temp = _pow(a,pos/2);
    if(pos % 2 == 1) return ( temp * temp*a)%n;
    return ( temp * temp )%n;
}
int main(){
    fin>>n>>m>>k>>x;
    fout<<(x+m*_pow(10, k))%n;
    return 0;
}

---

2.火柴排队
　　假设现在有两队火柴 a和b

　　a: 1 3 4 2

　　b: 1 2 3 5

　　因为它们的差的总值是一定的（化简一下，开开括号就得到了），为了使它们的差的平方的和最小，

所以a数列的第k小应该和b数列的第k小并在一起求差再求平方。

　　无论把a排成b，还是把b排成a都差不多，那就随便选一个，

　　下面又有一个问题，求什么的逆序对

　　将b中的元素应该在的位数写下来 1 4 2 3

　　如果将它排成1 2 3 4（带着原来的数一起排，绑定在一起）就意味着b数组被“排”成a数组了

所以应该是求它的逆序对（交换次数）

　　另外，注意，变算边取模

Code:

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#define _next(a) ((a)&(-a))
using namespace std;
typedef class IndexedTree{
    public:
        int *list;
        int size;
        IndexedTree():list(NULL),size(size){}
        IndexedTree(int size):size(size){
            list = new int[(const int)(size + 1)];
            memset(list, 0, sizeof(int) * (size + 1));
        }
        void add(int index, int value){
            while(index <= size){
                list[index] += value;
                index += (_next(index));
            }
        }
        long long getSum(int index){
            long long result = 0;
            while(index > 0){
                result += list[index];
                result %= 99999997;
                index -= (_next(index));
            }
            return result;
        }
}IndexedTree;
FILE *fin = fopen("match.in","r");
FILE *fout= fopen("match.out","w");
IndexedTree MyTree;
typedef struct mdata{
    int index;
    int height;
}mdata;
mdata *a;
mdata *b;
mdata *c;
int n;
long long result = 0;
typedef bool boolean;
boolean cmpare(const mdata &a, const mdata &b){
    return a.height < b.height;
}
int main(){
    fscanf(fin,"%d",&n);
    a = new mdata[(const int)(n + 1)];
    c = new mdata[(const int)(n + 1)];
    b = new mdata[(const int)(n + 1)];
    MyTree = IndexedTree(n);
    for(int i = 1;i <= n;i++){
        fscanf(fin,"%d",&a[i].height);
        a[i].index = i;
    }
    sort(a + 1, a + n + 1, cmpare);
    for(int i = 1;i <= n;i++){
        fscanf(fin,"%d",&b[i].height);
        b[i].index = i;
        c[i] = b[i];
    }
    sort(b + 1, b + n + 1, cmpare);
    for(int i = 1;i <= n;i++){
        c[b[i].index].index = a[i].index;
    }
    for(int i = 1;i <= n;i++){
        MyTree.add(c[i].index, 1);
        result += i - MyTree.getSum(c[i].index);
        result %= 99999997;
    }
    fprintf(fout,"%ld",result);
    return 0;
}

---

3.货车运输

60分程序:

　　思路就是先最大生成树，把无用的边都去掉，接着spfa

#include<iostream>
#include<queue>
#include<cstdio>
#include<cstring>
#include<algorithm>
#define _min(a,b) ((a) < (b))?(a):(b)
using namespace std;
int n,m,k;
FILE *fin = fopen("truck.in","r");
FILE *fout= fopen("truck.out","w");
typedef class Edge{
    public:
        int next;
        int end;
        int z;
        Edge():next(0),end(0),z(0){}
        Edge(int next, int end, int z):next(next),end(end),z(z){}
}Edge;
int *h;
int *h1;
Edge *edge1;
int _now = 0;
typedef struct gdata{
    int from;
    int end;
}gdata;
typedef bool boolean;
gdata g;
int buffer[3];
void add(int from, int end, int v){
    edge1[++_now] = Edge(h[from], end, v);
    h[from] = _now;
}
typedef struct Edge1{
    int from;
    int end;
    int v;
}Edge1; 
int *fset;    //并查集
int _find(int found){
    if(fset[found] != found) return ( fset[found] = _find(fset[found]) ); 
    return fset[found];
}
void unit(int &a, int &b){
    int af = _find(a);
    int bf = _find(b);
    fset[bf] = af;
}
queue<int> que;
boolean *visited;
int *f;
Edge1 *edge;
int solve(){
    memset(visited, false, sizeof(boolean) * (n + 1));
    memset(f,-1, sizeof(int) * (n + 1));
    if(h[g.end] == 0||h[g.from] == 0) return -1;
    f[g.from] = 1000000;
    visited[g.from] = true;
    que.push(g.from);
    while(!que.empty()){
        int u = que.front();
        que.pop();
        visited[u] = false;
        for(int i = h[u];i != 0;i = edge1[i].next){
            int eu = edge1[i].end;
            if(f[eu] < (_min(f[u] ,edge1[i].z))){
                f[eu] = (_min(f[u] ,edge1[i].z));
                if(!visited[eu]){
                    visited[eu] = true;
                    que.push(eu);
                }
            }
        }
    }
    if(f[g.end] < 0) return -1;
    return f[g.end];
}
boolean cmpare(const Edge1& a, const Edge1& b){
    return a.v > b.v;
}
void init_myTree(){
    fset = new int[(const int)(n + 1)];
    sort(edge+1, edge + m * 2 + 1, cmpare);
    for(int i = 1;i <= n; i++) fset[i] = i;
    int _count = 0;
    for(int i = 1;i <= m;i++){
        if(_count == n - 1) break;
        if(_find(edge[i].from) != _find(edge[i].end)){
            add(edge[i].from, edge[i].end, edge[i].v);
            add(edge[i].end, edge[i].from, edge[i].v);
            unit(edge[i].from, edge[i].end);
            _count++;
        }
    }
    delete[] edge;
    delete[] fset;
}
int main(){
    fscanf(fin,"%d%d",&n,&m);
    h = new int[(const int)(n + 1)];
    edge = new Edge1[(const int)(m * 2 + 1)];
    memset(h, 0, sizeof(int) * (n + 1));
    visited = new boolean[(const int)(n + 1)];
    f = new int[(const int)(n + 1)];
    edge1 = new Edge[(const int)(n * 2 + 1)];
    for(int i = 1;i <= m;i++){
        fscanf(fin,"%d%d%d",&edge[i].from,&edge[i].end,&edge[i].v);
    }
    init_myTree();
    fscanf(fin,"%d",&k);
    for(int i = 1;i <= k;i++){
        fscanf(fin,"%d%d",&g.from,&g.end);
        fprintf(fout,"%d
",solve());
    }
    return 0;
}

100分程序:

　　思路是这样的：

　　1.用并查集，把无用的边都去掉，得到几棵树

　　2.dfs进行初始化，注意不是只有一棵树

　　3.构造倍增数组，用up[i][j]表示i的第2^j 个父节点是多少，dis[i][j]表示i到up[i][j]的最大载重

　　4.进行倍增找lca，得到答案

Code（倍增）

/**
 * codevs.cn    & vijos.org
 * Problem#3287      Problem#1843
 * Accepted          Accepted
 * Time:416ms      Time:385ms
 * Memory:2108k      Memory:2472k
 */
#include<iostream>
#include<cstdio>
#include<fstream>
#include<cstring>
#include<queue>
#include<cctype>
#include<algorithm>
using namespace std;
typedef bool boolean;
#define INF 0xfffffff
#define smin(a, b) a = min(a, b)
#define smax(a, b) a = max(a, b)
template<typename T>
inline void readInteger(T& u){
    char x;
    while(!isdigit((x = getchar())));
    for(u = x - '0'; isdigit((x = getchar())); u = (u << 1) + (u << 3) + x - '0');
    ungetc(x, stdin);
}
///map template starts
typedef class Edge{
    public:
        int end;
        int next;
        int w;
        Edge(const int end = 0, const int next = 0, const int w = 0):end(end), next(next), w(w){}
}Edge;
typedef class MapManager{
    public:
        int ce;
        int *h;
        Edge *edge;
        MapManager(){}
        MapManager(int limit, int points):ce(0){
            h = new int[(const int)(points + 1)];
            edge = new Edge[(const int)(limit + 1)];
            memset(h, 0, sizeof(int) * (points + 1));
        }
        inline void addEdge(int from, int end, int w){
            edge[++ce] = Edge(end, h[from], w);
            h[from] = ce;
        }
        inline void addDoubleEdge(int from, int end, int w){
            addEdge(from, end, w);
            addEdge(end, from, w);
        }
}MapManager;
///map template ends
typedef class union_found{
    public:
        int *f;
        union_found():f(NULL) {}
        union_found(int points) {
            f = new int[(const int)(points + 1)];
            for(int i = 0; i <= points; i++)
                f[i] = i;
        }
        int find(int x) {
            if(f[x] != x)    return f[x] = find(f[x]);
            return f[x];
        }
        void unit(int fa, int so) {
            int ffa = find(fa);
            int fso = find(so);
            f[fso] = ffa;
        }
        boolean connected(int a, int b) {
            return find(a) == find(b);
        }
}union_found;

template<typename T>class Matrix{
    public:
        T *p;
        int lines;
        int rows;
        Matrix():p(NULL){    }
        Matrix(int lines, int rows):lines(lines), rows(rows){
            p = new T[(lines * rows)];
        }
        T* operator [](int pos){
            return (p + pos * lines);
        }
};

#define m_begin(g, i) (g).h[(i)]
#define m_end(g, i)    (g).edge[(i)].end
#define m_next(g, i) (g).edge[(i)].next
#define m_w(g, i)    (g).edge[(i)].w

typedef class _Edge{
    public:
        int from;
        int end;
        int w;
        _Edge():from(0), end(0), w(0){}
}_Edge;

int n;
int m;
_Edge* es;
inline void init(){
    readInteger(n);
    readInteger(m);
    es = new _Edge[(const int)(m + 1)];
    for(int i = 1; i <= m; i++){
        readInteger(es[i].from);
        readInteger(es[i].end);
        readInteger(es[i].w);
    }
}

boolean cmpare(const _Edge& a, const _Edge& b){
    return a.w > b.w;
}

MapManager g;
union_found uf;
inline void init_map(){
    g = MapManager(n * 2, n);
    uf = union_found(n);
    sort(es + 1, es + m + 1, cmpare);
    int finished = 0;
    for(int i = 1; i <= m; i++){
        if(!uf.connected(es[i].from, es[i].end)){
            uf.unit(es[i].from, es[i].end);
            g.addDoubleEdge(es[i].from, es[i].end, es[i].w);
            finished++;
        }
        if(finished == n - 1)    break;
    }
    delete[] es;
}

int* depth;
boolean* visited;
int* fa;
int* df;
void dfs(int node, int last, int dep, int dis){
    visited[node] = true;
    fa[node] = last;
    df[node] = dis;
    depth[node] = dep;
    for(int i = m_begin(g, node); i != 0; i = m_next(g, i)){
        int& e = m_end(g, i);
        if(visited[e])    continue;
        dfs(e, node, dep + 1, m_w(g, i));
    }
}

inline void init_dfs(){
    depth = new int[(const int)(n + 1)];
    visited = new boolean[(const int)(n + 1)];
    fa = new int[(const int)(n + 1)];
    df = new int[(const int)(n + 1)];
    memset(visited, false, sizeof(boolean) * (n + 1));
    for(int i = 1; i <= n; i++){
        if(!visited[i])
            dfs(i, 0, 1, 0);
    }
}

Matrix<int> up;
Matrix<int> dis;
inline void init_bz(){
    up = Matrix<int>(16, n + 1);
    dis = Matrix<int>(16, n + 1);
    memset(up.p, 0, sizeof(int) * 16 * (n + 1));
    memset(dis.p, 0x7f, sizeof(int) * 16 * (n + 1));
    for(int i = 1; i <= n; i++){
        up[i][0] = fa[i];
        dis[i][0] = df[i];
    }
    for(int j = 1; j <= 14; j++){
        for(int i = 1; i <= n; i++){
            up[i][j] = up[up[i][j - 1]][j - 1];
            dis[i][j] = min(dis[i][j - 1], dis[up[i][j - 1]][j - 1]);
        }
    }
}

int lca(int a, int b){    
    if(!uf.connected(a, b))    return -1;
    int result = 0xfffffff;
    if(depth[a] < depth[b])    swap(a, b);
    int c = depth[a] - depth[b];
    for(int i = 0; i <= 14; i++){
        if(c & (1 << i)){
            smin(result, dis[a][i]);
            a = up[a][i];
        }
    }
    if(a == b)    return result;
    for(int i = 14; i >= 0; i--){
        if(up[a][i] != up[b][i]){
            smin(result, dis[a][i]);
            smin(result, dis[b][i]);
            a = up[a][i];
            b = up[b][i];
        }
    }
    smin(result, dis[a][0]);
    smin(result, dis[b][0]);
    return result;
}

int q;
inline void solve(){
    readInteger(q);
    for(int i = 1, a, b; i <= q; i++){
        readInteger(a);
        readInteger(b);
        int l = lca(a, b);
        printf("%d
", l);
    }
}

///Main Funtion
int main(int argc, char* argv[]){
    init();
    init_map();
    init_dfs();
    init_bz();
    solve();
    return 0;
}

（代码有点长，还是比较便于理解）