国产福利电影一区二区三区久久老子无码午夜伦不 ,久久精品嫩草影院,亚洲AV无码久久精品成人

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

题意�Q�求一个n*n矩阵的最大子矩阵�?br />解题思�\�Q�类��g��l�情况下的最大连�l�子丌Ӏ?br />代码�Q?span style="font-size: 13px; background-color: #eeeeee;">#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 发表评论

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

题目大意�Q�求图上单点到单点之间的最短�\�?/div>

题目分析�Q�SPFA(Shortest Path Faster Algorithm)是Bellman-Ford��法的一�U�队列实玎ͼ�减少了不必要的冗余计��?/div>

��法大致��程是用一个队列来�q�行�l�护�?初始时将源加入队列�?每次从队列中取出一个元素，�q�对所有与他相�ȝ��点进行松弛，若某个相�ȝ��Ҏ��弛成功，则将其入队�?直到队列为空时算法结束�?/div>

�q�个��法�Q�简单的说就是队列优化的bellman-ford,利用了每个点不会更新�ơ数太多的特点发明的此算�?/div>

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

设Dist代表S到I点的当前最短距��，Fa代表S到I的当前最短�\径中I点之前的一个点的编受��开始时Dist全部�?∞�Q�只有Dist[S]=0�Q�Fa全部�?�?/div>

�l�护一个队列，里面存放所有需要进行�P代的炏V��初始时队列中只有一个点S。用一个布��数�l�记录每个点是否处在队列中�?/div>

每次�q�代�Q�取出队头的点v�Q�依�ơ枚举从v出发的边v->u�Q�设边的长度为len�Q�判断Dist[v]+len是否��于Dist[u]�Q�若��于则改�q�Dist[u]�Q�将Fa[u]��Cؓv�Q��ƈ且由于S到u的最短距��d��了�Q�有可能u可以改进其它的点�Q�所以若u不在队列中，��将它放入队��。这样一直�P代下�ȝ��到队列变�I�，也就是S到所有的最短距��都��定下来�Q�结束算法。若一个点入队�ơ数��过n�Q�则有负权环�?/div>

SPFA 在�Ş式上和宽度优先搜索非常类��|��不同的是宽度优先搜烦中一个点��Z��队列��׃��可能重新�q�入队列�Q�但是SPFA中一个点可能在出队列之后再次被放入队列，也就是一个点改进�q�其它的点之后，�q�了一�D�|��间可能本�w�被改进�Q�于是再�ơ用来改�q�其它的点，�q�样反复�q�代下去。设一个点用来作�ؓ�q�代点对其它点进行改�q�的�q�_��ơ数为k�Q�有办法证明对于通常的情况，k�?左右�?/div>

SPFA��法�Q�Shortest Path Faster Algorithm�Q�，也是求解单源最短�\径问题的一�U�算法，用来解决�Q�给定一个加权有向图G和源点s�Q�对于图G中的��L��一点v�Q�求从s到v的最短�\径�?SPFA��法是Bellman-Ford��法的一�U�队列实玎ͼ�减少了不必要的冗余计��，他的基本��法和Bellman-Ford一��P��q�且用如下的�Ҏ��改进�Q?1、第二步�Q�不是枚举所有节点，而是通过队列来进行优�?讄��一个先�q�先出的队列用来保存待优化的�l�点�Q�优化时每次取出队首�l�点u�Q��ƈ且用u点当前的最短�\径估计值对��d��u�Ҏ��指向的结点v�q�行村ּ�操作�Q�如果v点的最短�\径估计值有所调整�Q�且v点不在当前的队列中，��将v�Ҏ��入队��。这样不断从队列中取出结�Ҏ��q�行村ּ�操作�Q�直至队列空为止�?2、同旉��了通过判断队列是否为空来结束��@环，�q�可以通过下面的方法：判断有无负环�Q�如果某个点�q�入队列的次数超�q�V�ơ则存在负环�Q�SPFA无法处理带负环的图）�?/div>

SPFA��法有两个优化算�?SLF �?LLL�Q?SLF�Q�Small Label First �{�略�Q�设要加入的节点是j�Q�队首元素�ؓi�Q�若dist(j)x则将i插入到队��，查找下一元素�Q�直到找到某一i使得dist(i)<=x�Q�则��i出对�q�行村ּ�操作�?SLF 可��速度提高 15 ~ 20%�Q�SLF + LLL 可提高约 50%�?在实际的应用中SPFA的算法时间效率不是很�E�_��Q��ؓ了避免最坏情�늚�出现�Q�通常使用效率更加�E�_��的Dijkstra��法�?/div>

#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 单源最短�\�Q�Dijkstra��法堆优化）

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

题目大意�Q�求图上单点到单点之间的最短�\�?/div>

题目分析�Q�之前我们在同一道问题上分析�q�了单源最短�\问题�?a href="http://www.shnenglu.com/JulyRina/archive/2015/02/13/209818.html">Dijkstra��法�?br />

使用��L��矩阵实现的Dijkstra��法的时间复杂度是O(|V|^2)。��用邻接表的话�Q�更新最短距��d��需要更新每一条边卛_��Q�因此这部分的时间复杂度是O(|E|)。但是每�ơ要枚�D所有的��点来查找下一个��用的��点�Q�因此最�l�复杂度�q�是O(|V|^2)。在|E|比较��时�Q�大部分�l�历攑֜�了查找下一�ơ要是用的顶点上�Q�因此需要��用合适的数据�l�构对其�q�行优化�?/div>

需要优化的是数值的插入�Q�更斎ͼ�和取出最��g��个操作，因此使用堆就可以了。把每个��点当前的最短距��ȝ��堆维护，在更新最短距��L��Q�把对应的元素往根的方向�U�d��以满��_��的性质。而每�ơ从堆中取出的最��值就是下一�ơ要使用的顶炏V��这样堆中元素共有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

参数�Q�堆按照first从小到大的顺序取出�?/span>
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 发表评论

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

题目大意�Q�求图上单点到单点之间的最短�\�?/span>

题目分析�Q?/span>让我们考虑没有负边的情��c��在Bellman-Ford��法中，如果dist[i]�q�不是最短距��ȝ��话，那么即�ɘq�行dist[j]=dist[i]+(从i到j的边的权�?的更斎ͼ�dist[j]也不会变成最短距��R��而且�Q�即使dist[i]没有变化�Q�每一�ơ��@环也要检查一遍从i出发的所有变。这昄��是很��费旉��的。因此可以对��法作如下修攏V�?/span>

�Q?�Q�找到最短距��d��l�确定的��点�Q�从他出发更新相邻顶点的最短距��R�?/span>

�Q?�Q�此后不再需要关心（1�Q�中�?#8220;最短距��d��l�确定的��点”�?/span>

在（1�Q�和�Q?�Q�中提到�?#8220;最短距��d��l�确定的”要怎么得到旉��题的关键。在最开始时�Q�只有�v点的最短距��L��定的。而在��未使用�q�的��点中，距离dist[i]最��的��点��׃��加入“最短距��d��l�确定的��点”的阵营。这是因为由于不会存在负边，所以dist[i]不会在之后的更新中变��。这个算法叫做Dijkstra��法�?br />

#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 发表评论

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

题目大意�Q�求图上单点到单点之间的最短�\�?br />
题目分析�Q�单源最短�\问题是固定一个�v点，求它到其他所有点的最短�\的问题。终点也固定问题叫做两点之间最短�\问题。但是因为单源最短�\问题的复杂度是一��L��Q�因此通常当作单源最短�\问题来求解�?

��C��L��s出发到顶点i的最短距��Mؓdist[i]。则下述�{�式成立�?/div>

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

如果�l�定的图是一个DAG�Q�就可以按托不许�l�顶点编��P��q�利用这条递推关系计算出dist。但是，如果图中有圈�Q�就无法利用�q�样的关�p�进行计��?/div>

在这�U�情况下�Q�记当前到顶点i的最短距��Mؓdist[i]�Q��ƈ讑ֈ�值dist[s]=0�Q�dist[i]=INF�Q��够大的常敎ͼ��Q�再不断使用�q�条地推关系式更新dist��|��可以算出新的dist�?/div>

只要途中不存在负圈，�q�样的更新操作就是有限的。结束之后的最短操作就是所求的最短距��M��?br />

#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;
}

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 二分囄��多重匚w��(匈牙利算�?

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

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

题目分析�Q�直接徏立二分图模型�Q��用匈牙利��法�?/div>

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

解决多重匚w��是记录一下多重匹配的�?��U�Y方点)已经匚w��了Pi个点。如果Pi

因�ؓYi搜一�ơ就需要染色了�Q�而且Y方点最多是10个，所以每�ơ找增广路的深度最多是10�Q�这样就很快了�?/div>

#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 发表评论

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

题目大意�Q�动物王国中有三�c�d��物A,B,C�Q�这三类动物的食物链构成了有��的环�Ş。A吃B�Q?B吃C�Q�C吃A�?nbsp;

现有N个动物，�?�Q�N�~�号。每个动物都是A,B,C中的一�U�，但是我们�q�不知道它到底是哪一�U��?nbsp;

有�h用两�U�说法对�q�N个动物所构成的食物链关系�q�行描述�Q?nbsp;

�W�一�U�说法是"1 X Y"�Q�表�C�X和Y是同�c�R�?nbsp;

�W�二�U�说法是"2 X Y"�Q�表�C�X吃Y�?nbsp;

此�h对N个动物，用上�q�C��U�说法，一句接一句地说出K句话�Q�这K句话有的是真的，有的是假的。当一句话满��下列三条之一�Ӟ��q�句话就是假话，否则��是真话�?nbsp;

1�Q?span style="white-space:pre"> 当前的话与前面的某些真的话冲�H�，��是假话�Q?nbsp;

2�Q?span style="white-space:pre"> 当前的话中X或Y比N大，��是假话�Q?nbsp;

3�Q?span style="white-space:pre"> 当前的话表示X吃X�Q�就是假话�?nbsp;

你的��d��是根据给定的N�Q? <= N <= 50,000�Q�和K句话�Q? <= K <= 100,000�Q�，输出假话的��L��?nbsp;

题目分析�Q�由于N和K很大�Q�所以必��高效的�l�护动物之间的关�p�，�q�快速判断是否残生了矛盾�Q�所以决定采用�ƈ查集�?/div>

对于每只动物i创徏3个元素i,i+N,i+2N,�q�用�q?*N个元素创建�ƈ查集。这个�ƈ查集�l�护如下信息�Q?/div>

i+xN表示“i属于�U�类x”�?/div>

�q�查集里的每一个组表示�l�内所有元素代表的都同时发生或不发生�?/div>

同时�Q�在合�ƈ之前先判断合�q�是否会产生矛盾�?/div>

#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 发表评论

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

题目大意�Q�给定长度�ؓN的字�W�串S�Q�要构造一个长度�ؓN的字�W�串T。�v初，T是一个空�Ԍ��随后反复�q�行下列��L��操作�?/div>

从S的头部删除一个字�W�，加到T的尾�?/div>

从S的尾部删除一个字�W�，加到T的尾�?/div>

目标是构造字典序��可能小的字�W�串�?/div>

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

不断取S和T的末��中较小的一个字�W�放到T的末��?/div>

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

按照字典序比较字�W�串S和S反�{后的字符串S'�?/div>

如果S较小�Q�就从S的开头取��Z��个文字，攑ֈ�T的末��?/div>

如果S'较小�Q�就从S的末��֏��Z��个文字，攑ֈ�T的末��?/div>

�Q�若果相同则��d��一个都可以�Q?/div>

#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

题目大意�Q�有一个大��ؓN*M的园子，雨后�U��v了水。八�q�通的�U�水被认为是�q�接在一��L��。请求出园子里��d��有多��水�z�|��

�Q�八�q�通指下图中相当于W�?�Q?/div>

***

*W*

***

题目分析�Q�从��L��的W开始，不同的用一个vis数组标记是否讉K��q�。一�ơDFS后与初始的这个W相连的W��都被标记过了。因此知道途中不再存在W为止�Q��d��q�行DFS的次数就是答案了�?/div>

#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

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

题目分析�Q�虽然当蚂蚁数量很多的时候情况会有很多种�Q�但是先考虑��数量的分析��可以找到解��x��法：如果只有两只的话�Q�那么最短时间就是两只蚂蚁距��M��端点距离较小的距��M��取大者就是所需最短时��_��而最长时间就是两只蚂蚁距��M��端点距离较大者中取大者就是所需最长时��_��例如�Q�长度�ؓ10�Q�一只在距离左端2的位�|�，一只在距离左端6的位�|�，则最短时间�ؓmax(min(2,10-2),min(6,10-6))�?,最长时间�ؓmax((max(2,10-2),max(6,10-6)))�?其实��是两只相向而行�Q�当盔R��后，都�{为逆向�Q�则旉��Z��盔R��点到端点距离大者与盔R��前所需旉��Q�分析实际就�?�?0的距��，当蚂蚁数量增加时�Q�情�늛�同�?/div>

则需要时间最长的的就是让距离端点最�q�的蚂蚁爬到另一个端�?最�q?所需要的旉��?/div>

也就是说�Q�只要找出所有蚂蚁与较远端比较，然后扑և�最大值就是所需要的最大时间�?/div>

�q�里需要注意的��是两只蚂蚁盔R��转向的那个梗。事实上�Q�可以知道两只蚂蚁相遇后�Q�当他们保持原样交错而过�l�箋前进也不会有��M��问题。这��L��来，可以认�ؓ每只蚂蚁都是独立�q�动的，所以要求最长时��_��只要求蚂蚁到杆子端点的最大距��d��好了�?br />

#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 发表评论

国产福利电影一区二区三区久久老子无码午夜伦不 ,久久精品嫩草影院,亚洲AV无码久久精品成人

POJ 2387 Til the Cows Come Home 单源最短�\�Q�Dijkstra���法 堆优化）

HDU 3605 Escape 二分囄���多重匚w��(匈牙利算�?

POJ 2386 Lake Counting ���单DFS

POJ 1852 Ants

POJ 2387 Til the Cows Come Home 单源最短�\�Q�Dijkstra��法堆优化）

HDU 3605 Escape 二分囄��多重匚w��(匈牙利算�?

POJ 2386 Lake Counting ��单DFS