C++博客-JulyRina's blog-随笔分类-解题报告

POJ 1050 To the Max 最大子矩阵动态规划

JulyRina — Tue, 31 Mar 2015 15:15:00 GMT

题意：求一个n*n矩阵的最大子矩阵。
解题思路：类似一维情况下的最大连续子串。
代码：#include <cstdio>

#include
#include
#include
using namespace std;
const int maxn = 110;
int n, a[maxn][maxn], r[maxn][maxn] , f[maxn];
int main() {
    while(~scanf("%d", &n)) {
        for(int i=1;i<=n;i++)
            for(int j=1;j<=n;j++)
                scanf("%d", &a[i][j]);
        for(int i=1;i<=n;i++)
            for(int j=1;j<=n;j++)
                r[i][j] = r[i-1][j] + a[i][j];
        int ans = a[0][0];
        for(int i=1;i<=n;i++)
            for(int j=i;j<=n;j++)
            for(int k=1;k<=n;k++) {
                if(f[k-1] < 0) {
                    f[k] = r[j][k] - r[i-1][k];
                } else {
                    f[k] = f[k-1] + r[j][k] - r[i-1][k];
                }
                if(f[k] > ans) ans = f[k];
            }
        printf("%d\n", ans);
    }
    return 0;
}

JulyRina 2015-03-31 23:15 发表评论

POJ 2387 Til the Cows Come Home 单源最短路（SPFA算法）

JulyRina — Fri, 13 Feb 2015 11:42:00 GMT

题目大意：求图上单点到单点之间的最短路。

题目分析：SPFA(Shortest Path Faster Algorithm)是Bellman-Ford算法的一种队列实现，减少了不必要的冗余计算。

算法大致流程是用一个队列来进行维护。初始时将源加入队列。每次从队列中取出一个元素，并对所有与他相邻的点进行松弛，若某个相邻的点松弛成功，则将其入队。直到队列为空时算法结束。

这个算法，简单的说就是队列优化的bellman-ford,利用了每个点不会更新次数太多的特点发明的此算法

SPFA——Shortest Path Faster Algorithm，它可以在O(kE)的时间复杂度内求出源点到其他所有点的最短路径，可以处理负边。SPFA的实现甚至比Dijkstra或者Bellman_Ford还要简单：

设Dist代表S到I点的当前最短距离，Fa代表S到I的当前最短路径中I点之前的一个点的编号。开始时Dist全部为+∞，只有Dist[S]=0，Fa全部为0。

维护一个队列，里面存放所有需要进行迭代的点。初始时队列中只有一个点S。用一个布尔数组记录每个点是否处在队列中。

每次迭代，取出队头的点v，依次枚举从v出发的边v->u，设边的长度为len，判断Dist[v]+len是否小于Dist[u]，若小于则改进Dist[u]，将Fa[u]记为v，并且由于S到u的最短距离变小了，有可能u可以改进其它的点，所以若u不在队列中，就将它放入队尾。这样一直迭代下去直到队列变空，也就是S到所有的最短距离都确定下来，结束算法。若一个点入队次数超过n，则有负权环。

SPFA 在形式上和宽度优先搜索非常类似，不同的是宽度优先搜索中一个点出了队列就不可能重新进入队列，但是SPFA中一个点可能在出队列之后再次被放入队列，也就是一个点改进过其它的点之后，过了一段时间可能本身被改进，于是再次用来改进其它的点，这样反复迭代下去。设一个点用来作为迭代点对其它点进行改进的平均次数为k，有办法证明对于通常的情况，k在2左右。

SPFA算法（Shortest Path Faster Algorithm），也是求解单源最短路径问题的一种算法，用来解决：给定一个加权有向图G和源点s，对于图G中的任意一点v，求从s到v的最短路径。 SPFA算法是Bellman-Ford算法的一种队列实现，减少了不必要的冗余计算，他的基本算法和Bellman-Ford一样，并且用如下的方法改进： 1、第二步，不是枚举所有节点，而是通过队列来进行优化设立一个先进先出的队列用来保存待优化的结点，优化时每次取出队首结点u，并且用u点当前的最短路径估计值对离开u点所指向的结点v进行松弛操作，如果v点的最短路径估计值有所调整，且v点不在当前的队列中，就将v点放入队尾。这样不断从队列中取出结点来进行松弛操作，直至队列空为止。 2、同时除了通过判断队列是否为空来结束循环，还可以通过下面的方法：判断有无负环：如果某个点进入队列的次数超过V次则存在负环（SPFA无法处理带负环的图）。

SPFA算法有两个优化算法 SLF 和 LLL： SLF：Small Label First 策略，设要加入的节点是j，队首元素为i，若dist(j)x则将i插入到队尾，查找下一元素，直到找到某一i使得dist(i)<=x，则将i出对进行松弛操作。 SLF 可使速度提高 15 ~ 20%；SLF + LLL 可提高约 50%。在实际的应用中SPFA的算法时间效率不是很稳定，为了避免最坏情况的出现，通常使用效率更加稳定的Dijkstra算法。

#include
#include
#include
#include
using namespace std;
#define INF (1<<29)
const int maxn = 1010;

typedef pair<int, int> P;
vector

G[maxn];
queue<int> que;
int V, E, dist[maxn];
bool vis[maxn];

void spfa(int s) {
    fill(dist, dist+V, INF);
    fill(vis, vis+V, false);
    dist[s] = 0;
    while(!que.empty()) que.pop();
    que.push(s);
    while(!que.empty()) {
        int u = que.front();
        que.pop();
        vis[u] = false;
        int sz = G[u].size();
        for(int i=0;i            int v = G[u][i].first;
            int w = G[u][i].second;
            if(dist[v] > dist[u] + w) {
                dist[v] = dist[u] + w;
                if(!vis[v]) {
                    vis[v] = true;
                    que.push(v);
                }
            }
        }
    }
}

int main() {
    scanf("%d%d" , &E, &V);
    for(int i=0;i    for(int i=0;i        int u, v, w;
        scanf("%d%d%d" , &u, &v, &w);
        u --; v --;
        G[u].push_back(make_pair(v, w));
        G[v].push_back(make_pair(u, w));
    }
    spfa(0);
    printf("%d\n", dist[V-1]);
    return 0;
}

JulyRina 2015-02-13 19:42 发表评论

POJ 2387 Til the Cows Come Home 单源最短路（Dijkstra算法堆优化）

JulyRina — Fri, 13 Feb 2015 11:38:00 GMT

题目大意：求图上单点到单点之间的最短路。

题目分析：之前我们在同一道问题上分析过了单源最短路问题的Dijkstra算法。

使用邻接矩阵实现的Dijkstra算法的时间复杂度是O(|V|^2)。使用邻接表的话，更新最短距离只需要更新每一条边即可，因此这部分的时间复杂度是O(|E|)。但是每次要枚举所有的顶点来查找下一个使用的顶点，因此最终复杂度还是O(|V|^2)。在|E|比较小时，大部分经历放在了查找下一次要是用的顶点上，因此需要使用合适的数据结构对其进行优化。

需要优化的是数值的插入（更新）和取出最小值两个操作，因此使用堆就可以了。把每个顶点当前的最短距离用堆维护，在更新最短距离时，把对应的元素往根的方向移动以满足堆的性质。而每次从堆中取出的最小值就是下一次要使用的顶点。这样堆中元素共有O(|V|)个，更新和取出数值的操作有O(|E|)次，因此整个算法的复杂度是O(|E|log(V))

#include
#include
#include
#include
using namespace std;
#define INF (1<<29)
const int maxn = 1010;

typedef pair<int, int> P; //first是最短距离，second是顶点的编号
int V, dist[maxn];
vector

G[maxn];

void dijkstra(int s) {
//通过指定greater

参数，堆按照first从小到大的顺序取出值
priority_queue, greater

> que;
    fill(dist, dist + V , INF);
    dist[s] = 0;
    while(!que.empty()) que.pop();
    que.push(P(0, s));
    while(!que.empty()) {
        P p = que.top(); que.pop();
        int u = p.second;
        if(dist[u] < p.first) continue;
        int sz = G[u].size();
        for(int i=0;i             int to = G[u][i].second;
            int cost = G[u][i].first;
            if(dist[to] > dist[u] + cost) {
                dist[to] = dist[u] + cost;
                que.push(P(dist[to], to));
            }
        }
    }
}

int main() {
    int m;
    scanf("%d%d" , &m, &V);
    for(int i=0;i     for(int i=0;i         int from, to, cost;
        scanf("%d%d%d" , &from, &to, &cost);
        from --; to --;
        G[from].push_back(P(cost, to));
        G[to].push_back(P(cost, from));
    }
    dijkstra(0);
    printf("%d\n", dist[V-1]);
    return 0;
}

JulyRina 2015-02-13 19:38 发表评论

POJ 2387 Til the Cows Come Home 单源最短路（Dijkstra算法）

JulyRina — Fri, 13 Feb 2015 11:34:00 GMT

题目大意：求图上单点到单点之间的最短路。

题目分析：让我们考虑没有负边的情况。在Bellman-Ford算法中，如果dist[i]还不是最短距离的话，那么即使进行dist[j]=dist[i]+(从i到j的边的权值)的更新，dist[j]也不会变成最短距离。而且，即使dist[i]没有变化，每一次循环也要检查一遍从i出发的所有变。这显然是很浪费时间的。因此可以对算法作如下修改。

（1）找到最短距离已经确定的顶点，从他出发更新相邻顶点的最短距离。

（2）此后不再需要关心（1）中的“最短距离已经确定的顶点”。

在（1）和（2）中提到的“最短距离已经确定的”要怎么得到时问题的关键。在最开始时，只有起点的最短距离是确定的。而在尚未使用过的顶点中，距离dist[i]最小的顶点就会加入“最短距离已经确定的顶点”的阵营。这是因为由于不会存在负边，所以dist[i]不会在之后的更新中变小。这个算法叫做Dijkstra算法。

#include
#include
#include
using namespace std;
#define INF (1<<29)
const int maxn = 1010;

typedef pair<int, int> P;
vector

G[maxn];
int V, E, dist[maxn];
bool vis[maxn];

void dijkstra(int s) {
    fill(dist, dist + V, INF);
    fill(vis, vis + V, false);
    dist[s] = 0;
    while(true) {
        int u = -1;
        for(int i=0;i             if(!vis[i] && (u == -1 || dist[i] < dist[u]))
                u = i;
        if(u == -1) break;
        vis[u] = true;
        int sz = G[u].size();
        for(int i=0;i             int v = G[u][i].first;
            int w = G[u][i].second;
            dist[v] = min(dist[v], dist[u] + w);
        }
    }
}

int main() {
    scanf("%d%d" , &E, &V);
    for(int i=0;i     for(int i=0;i         int u, v, w;
        scanf("%d%d%d" , &u, &v, &w);
        u --; v --;
        G[u].push_back(make_pair(v, w));
        G[v].push_back(make_pair(u, w));
    }
    dijkstra(0);
    printf("%d\n", dist[V-1]);
    return 0;
}

JulyRina 2015-02-13 19:34 发表评论

POJ 2387 Til the Cows Come Home 单源最短路（Bellman-ford算法）

JulyRina — Fri, 13 Feb 2015 11:32:00 GMT

题目大意：求图上单点到单点之间的最短路。

题目分析：单源最短路问题是固定一个起点，求它到其他所有点的最短路的问题。终点也固定问题叫做两点之间最短路问题。但是因为单源最短路问题的复杂度是一样的，因此通常当作单源最短路问题来求解。

记从起点s出发到顶点i的最短距离为dist[i]。则下述等式成立。

dist[i] = min{dist[j]+(从j到i的边的权值)|e=(j,i)∈E}

如果给定的图是一个DAG，就可以按托不许给顶点编号，并利用这条递推关系计算出dist。但是，如果图中有圈，就无法利用这样的关系进行计算。

在这种情况下，记当前到顶点i的最短距离为dist[i]，并设初值dist[s]=0，dist[i]=INF（足够大的常数），再不断使用这条地推关系式更新dist值，就可以算出新的dist。

只要途中不存在负圈，这样的更新操作就是有限的。结束之后的最短操作就是所求的最短距离了。

#include
#include
#include
#include
using namespace std;
#define INF (1<<29)
const int maxn = 1010, maxm = 4040;

int n, m;

struct Edge { int from, to, cost; } edge[maxm];
int V, E, dist[maxn];

void bellman_ford(int s) {
    for(int i=0;i     dist[s] = 0;
    while(true) {
        bool update = false;
        for(int i=0;i             Edge e = edge[i];
            if(dist[e.from] != INF && dist[e.to] > dist[e.from] + e.cost) {
                dist[e.to] = dist[e.from] + e.cost;
                update = true;
            }
        }
        if(!update) break;
    }
}

int main() {
    scanf("%d%d" , &m, &n);
    V = n; E = 2 * m;
    for(int i=0;i         Edge e;
        int from, to, cost;
        scanf("%d%d%d" , &from, &to, &cost);
        from --; to --;
        edge[i].from = from;
        edge[i].to = to;
        edge[i].cost = cost;
        edge[i+1].from = to;
        edge[i+1].to = from;
        edge[i+1].cost = cost;
    }
    bellman_ford(0);
    printf("%d", dist[n-1]);
    return 0;
}

这个算法叫做Bellman-Ford算法。如果在图中不存在从s可达的负圈，那么最短路不会经过同一个顶点两次（也就是说，最多通过|V|-1次），while(true)的循环最多经过|V|-1次，因此，复杂度是O(VE)。反之，如果存在从s可达的负圈，那么在第|V|次循环中也会更新dist的值，因此也可以用这个性质来检查负圈。如果一开始对所有的i，都把dist[i]设为0，那么可以检查出所有的负圈。

bool find_negetive_loop() {
    memset(dist, 0, sizeof(dist));

    for(int i=0;i         for(int j=0;j             if(dist[e.to] > dist[e.from] + e.cost) {
                dist[e.to] = dist[e.from] + e.cost;
                if(i == V-1) return true;
            }
        }
    }
    return false;
}

JulyRina 2015-02-13 19:32 发表评论

HDU 3605 Escape 二分图的多重匹配(匈牙利算法)

JulyRina — Fri, 13 Feb 2015 08:23:00 GMT

题目大意：有N(N<100,000)个人要去M(M<10)个星球，每个人只可以去一些星球，一个星球最多容纳Ki个人。请问是否所有人都可以选择自己的星球

题目分析；直接建立二分图模型，使用匈牙利算法。

匈牙利算法可以解决多重匹配，原理和二分图最大匹配很像。注意不要把可以匹配多个的点分割然后按照正常的二分匹配来做，那样肯定会挂的。

解决多重匹配就是记录一下多重匹配的点(简称Y方点)已经匹配了Pi个点。如果Pi

因为Yi搜一次就需要染色了，而且Y方点最多是10个，所以每次找增广路的深度最多是10，这样就很快了。

#include
#include
#include
using namespace std;

const int maxn = 100010;
const int maxm = 11;
int y_match[maxn][maxm], g[maxn][maxm], cnt[maxm], capacity[maxn], n, m;
bool vis[maxm];

bool dfs(int x) {
    for(int i=0;i        if(g[x][i] == 0 || vis[i] == true) continue;
        vis[i] = true;
        if(cnt[i] < capacity[i]) {
            y_match[x][cnt[i]++] = x;
            return true;
        } else {
            for(int j=0;j                if(dfs(y_match[i][j]) == true) {
                    y_match[i][j] = x;
                    return true;
                }
            }
        }
    }
    return false;
}
bool hungary(int n) {
    for(int i=0;i        memset(vis, false, sizeof(bool)*(m));
        if(dfs(i) == false)
            return false;
    }
    return true;
}
int main() {
    while(~scanf("%d%d" , &n, &m)) {
        memset(cnt, 0, sizeof(int)*(n));
        for(int i=0;i            for(int j=0;j                scanf("%d", &g[i][j]);
        for(int i=0;i            scanf("%d", &capacity[i]);
        if(hungary(n) == true)
            puts("YES");
        else
            puts("NO");
    }
    return 0;
}

JulyRina 2015-02-13 16:23 发表评论

POJ 1182 食物链并查集

JulyRina — Wed, 11 Feb 2015 09:33:00 GMT

题目大意：动物王国中有三类动物A,B,C，这三类动物的食物链构成了有趣的环形。A吃B， B吃C，C吃A。

现有N个动物，以1－N编号。每个动物都是A,B,C中的一种，但是我们并不知道它到底是哪一种。

有人用两种说法对这N个动物所构成的食物链关系进行描述：

第一种说法是"1 X Y"，表示X和Y是同类。

第二种说法是"2 X Y"，表示X吃Y。

此人对N个动物，用上述两种说法，一句接一句地说出K句话，这K句话有的是真的，有的是假的。当一句话满足下列三条之一时，这句话就是假话，否则就是真话。

1）当前的话与前面的某些真的话冲突，就是假话；

2）当前的话中X或Y比N大，就是假话；

3）当前的话表示X吃X，就是假话。

你的任务是根据给定的N（1 <= N <= 50,000）和K句话（0 <= K <= 100,000），输出假话的总数。

题目分析；由于N和K很大，所以必须高效的维护动物之间的关系，并快速判断是否残生了矛盾，所以决定采用并查集。

对于每只动物i创建3个元素i,i+N,i+2N,并用这3*N个元素创建并查集。这个并查集维护如下信息：

i+xN表示“i属于种类x”。

并查集里的每一个组表示组内所有元素代表的都同时发生或不发生。

同时，在合并之前先判断合并是否会产生矛盾。

#include
#include
using namespace std;

const int maxn = 50050;

int father[maxn*3], n, m, ans;

void init() {
    for(int i=0;i<3*n;i++) father[i] = i;
}
int find(int x) {
    return x == father[x] ? x : father[x] = find(father[x]);
}
void unite(int x, int y) {
    int a = find(x) , b = find(y);
    father[a] = father[b] = father[x] = father[y] = min(a, b);
}
bool check(int d, int x, int y) {
    if(x >= n || y >= n || x < 0 || y < 0)
        return false;
    if(d == 2 && x == y)
        return false;
    if(d == 1) {
        if(find(x) == find(y+n) || find(x) == find(y+2*n))
            return false;
        unite(x, y);
        unite(x+n, y+n);
        unite(x+2*n, y+2*n);
        return true;
    } else {
        if(find(x) == find(y) || find(x) == find(y+2*n))
            return false;
        unite(x, y+n);
        unite(x+n, y+2*n);
        unite(x+2*n, y);
        return true;
    }
}
int main() {
    scanf("%d%d" , &n, &m);
    init();
    ans = 0;
    for(int i=0;i        int d, x, y;
        scanf("%d%d%d", &d, &x, &y);
        x --; y --;
        if(check(d, x, y) == false)
            ans ++;
    }
    printf("%d\n", ans);
    return 0;
}

JulyRina 2015-02-11 17:33 发表评论

POJ 3617 Best Cow Line 简单贪心

JulyRina — Wed, 11 Feb 2015 07:59:00 GMT

题目大意：给定长度为N的字符串S，要构造一个长度为N的字符串T。起初，T是一个空串，随后反复进行下列任意操作。

从S的头部删除一个字符，加到T的尾部

从S的尾部删除一个字符，加到T的尾部

目标是构造字典序尽可能小的字符串。

题目分析；从字典序的性质上看，无论T的末尾有多大，只要前面部分较小就可以。所以我们可以试一下如下贪心算法：

不断取S和T的末尾中较小的一个字符放到T的末尾

这个算法已经接近正确了，只是针对S的开头和末尾字符相同的情形还没有定义。在这种情况下，因为我们希望能够尽早使用更小的字符，所以就要比较一下下一个字符的大小。下一个字符也有可能相同，因此就有如下算法：

按照字典序比较字符串S和S反转后的字符串S'。

如果S较小，就从S的开头取出一个文字，放到T的末尾。

如果S'较小，就从S的末尾取出一个文字，放到T的末尾。

（若果相同则去哪一个都可以）

#include

char s[2002], tmp[2];
int n;

int main() {
    while(~scanf("%d", &n)) {
        for(int i=0;i            scanf("%s", tmp);
            s[i] = tmp[0];
        }
        int l = 0, r = n - 1, cnt = 0;
        while(l <= r) {
            int i = 0, left = true;
            while(l + i <= r - i) {
                if(s[l+i] < s[r-i]) {
                    break;
                }
                if(s[l+i] > s[r-i]) {
                    left = false;
                    break;
                }
                i ++;
            }
            if(left == true) putchar(s[l++]);
            else putchar(s[r--]);
            cnt ++;
            if(cnt % 80 == 0) putchar('\n');
        }
        if(cnt % 80) putchar('\n');
    }
    return 0;
}

JulyRina 2015-02-11 15:59 发表评论

POJ 2386 Lake Counting 简单DFS

JulyRina — Wed, 11 Feb 2015 07:29:00 GMT

题目大意：有一个大小为N*M的园子，雨后积起了水。八连通的积水被认为是连接在一起的。请求出园子里总共有多少水洼？

（八连通指下图中相当于W的*）

***

*W*

***

题目分析；从任意的W开始，不同的用一个vis数组标记是否访问过。一次DFS后与初始的这个W相连的W就都被标记过了。因此知道途中不再存在W为止，总共进行DFS的次数就是答案了。

#include
#include

const int maxn = 101;

int n, m, ans;
char g[maxn][maxn];
bool vis[maxn][maxn];

void dfs(int x, int y) {
    if(vis[x][y] == true || g[x][y] != 'W') return;
    vis[x][y] = true;
    for(int i=-1;i<=1;i++)
    for(int j=-1;j<=1;j++) {
        if(!i && !j || x + i < 0 || x + i >= n || y + j < 0 || y + j >= m) continue;
        dfs(x+i, y+j);
    }
    return;
}

int main() {
    while(~scanf("%d%d" , &n, &m)) {
        for(int i=0;i            scanf("%s", g[i]);
            memset(vis+i, false, sizeof(bool)*(m));
        }
        ans = 0;
        for(int i=0;i            for(int j=0;j                if(g[i][j] == 'W' && !vis[i][j]) {
                    ans ++;
                    dfs(i, j);
                }
        printf("%d\n", ans);
    }
    return 0;
}

JulyRina 2015-02-11 15:29 发表评论

POJ 1852 Ants

JulyRina — Wed, 11 Feb 2015 07:09:00 GMT

题目大意：很多的蚂蚁都在长度为L（cm）的杆子上爬行，它们的速度都是1cm/s，到了棒子终端的时候，蚂蚁就会掉下去。如果在爬行途中遇到其他蚂蚁，两只蚂蚁的方向都会逆转。已知蚂蚁在棒子的最初位置坐标，但是我们不知道他们会往哪一个方向爬。请求出所有蚂蚁掉下去的最短时间和最长时间。

题目分析：虽然当蚂蚁数量很多的时候情况会有很多种，但是先考虑小数量的分析就可以找到解决方法：如果只有两只的话，那么最短时间就是两只蚂蚁距离两端点距离较小的距离中取大者就是所需最短时间，而最长时间就是两只蚂蚁距离两端点距离较大者中取大者就是所需最长时间，例如，长度为10，一只在距离左端2的位置，一只在距离左端6的位置，则最短时间为max(min(2,10-2),min(6,10-6))为4,最长时间为max((max(2,10-2),max(6,10-6)))为8其实就是两只相向而行，当相遇后，都转为逆向，则时间为从相遇点到端点距离大者与相遇前所需时间，分析实际就是2到10的距离，当蚂蚁数量增加时，情况相同。

则需要时间最长的的就是让距离端点最近的蚂蚁爬到另一个端点(最远)所需要的时间。

也就是说，只要找出所有蚂蚁与较远端比较，然后找出最大值就是所需要的最大时间。

这里需要注意的就是两只蚂蚁相遇转向的那个梗。事实上，可以知道两只蚂蚁相遇后，当他们保持原样交错而过继续前进也不会有任何问题。这样看来，可以认为每只蚂蚁都是独立运动的，所以要求最长时间，只要求蚂蚁到杆子端点的最大距离就好了。

#include
#include
using namespace std;

int min_time, max_time;
int h, n, T, tmp;

int main() {
    scanf("%d", &T);
    while(T--) {
        scanf("%d%d" , &h, &n);
        min_time = 0;
        max_time = 0;
        for(int i=0;i            scanf("%d", &tmp);
            min_time = max(min_time, min(tmp, h - tmp));
            max_time = max(max_time, max(tmp, h - tmp));
        }
        printf("%d %d\n", min_time, max_time);
    }
    return 0;
}

JulyRina 2015-02-11 15:09 发表评论