2017年10月17日-ACM涉及知识需掌握

原创

DeathYmz 2022-08-22 21:21:10 博主文章分类：算法学习 ©著作权

©著作权归作者所有：来自51CTO博客作者DeathYmz的原创作品，请联系作者获取转载授权，否则将追究法律责任

2017 ACM/ICPC Asia Regional shenyang Online
部分解释：
6200：（dfs序）树状数组问题
6201：超级源点汇点（网络流），点权转化边权,spfa最长路径
6202：八面八轴魔方模拟，样例找关系写脚本
6205：暴力，贪心思想模拟题水题
6203：LCA，DFS 树状数组

一：树状数组问题：
搞懂树状数组
树状数组（模板）

//树状数组的一维和二维模板模板

int lowbit(int x)
{
    return x & (-x);
}
void modify(int x,int add)//一维
{  
    while(x<=MAXN)  
    {      
        a[x]+=add;    
        x+=lowbit(x); 
    }
}
int get_sum(int x)
{  
    int ret=0; 
    while(x!=0)  
    {       
        ret+=a[x];   
        x-=lowbit(x);   
    }  
    return ret;
}
void modify(int x,int y,int data)//二维
{
    for(int i=x;i<MAXN;i+=lowbit(i))
        for(int j=y;j<MAXN;j+=lowbit(j))
            a[i][j]+=data;
}
int get_sum(int x,int y)
{
    int res=0;
    for(int i=x;i>0;i-=lowbit(i))
        for(int j=y;j>0;j-=lowbit(j))
            res+=a[i][j];
    return

二：超级源点汇点（网络流）：
网络流本质上是为了解决一类取舍问题，这类取舍问题无法得知最优策略的模式（无法DP），因此通过构造一些带容量的路径表示原题目容量，模拟水流在这些容量之间的取舍，从而可以利用网络流来解决取舍问题。
【算法】网络流
网络流模板大全

//很复杂我不会

三：spfa最长路径：
(最短路径算法整理)dijkstra、floyd、bellman-ford、spfa算法模板的整理与介绍
单源最短路 SPFA 算法模板
使用spfa算法来解决。
思想：用于求单源最短路径，可以适用于负边权的情况。spfa(Shortest Path Faster Algorithm)算法其实不是什么很难理解的算法，它只是bellman-ford的队列优化而已。
模板：

#include <iostream>  
#include <cstring>  
#include <queue>  
using namespace std;  

const int N = 105;  
const int INF = 99999999;  

int map[N][N], dist[N];  
bool visit[N];  
int n, m;  

void init() {//初始化  
    int i, j;  
    for (i = 1; i < N; i++) {  
        for (j = 1; j < N; j++) {  
            if (i == j) {  
                map[i][j] = 0;  
            } else {  
                map[i][j] = map[j][i] = INF;  
            }  
        }  
    }  
}  

/** 
 * SPFA算法. 
 * 使用spfa算法来求单元最短路径 
 * 参数说明: 
 * start:起点 
 */  
void spfa(int start) {  
    queue<int> Q;  

    int i, now;  
    memset(visit, false, sizeof(visit));  
    for (i = 1; i <= n; i++){  
        dist[i] = INF;  
    }  

    dist[start] = 0;  
    Q.push(start);  
    visit[start] = true;  
    while (!Q.empty()) {  
        now = Q.front();  
        Q.pop();  
        visit[now] = false;  
        for (i = 1; i <= n; i++) {  
            if (dist[i] > dist[now] + map[now][i]) {  
                dist[i] = dist[now] + map[now][i];  
                if (visit[i] == 0) {  
                    Q.push(i);  
                    visit[i] = true;  
                }  
            }  
        }  
    }  
}