BNU 26480 Horror List【最短路】

链接：

http://www.bnuoj.com/bnuoj/problem_show.php?pid=26480

http://www.bnuoj.com/bnuoj/contest_show.php?cid=2317#problem/25682

Horror List

Time Limit: 1000ms

Memory Limit: 65536KB

 

64-bit integer IO format:  %lld      Java class name:  Main

Prev  Submit  Status  Statistics  Discuss  Next

Font Size:  +   -

Type:    None   Graph Theory       2-SAT       Articulation/Bridge/Biconnected Component       Cycles/Topological Sorting/Strongly Connected Component       Shortest Path           Bellman Ford           Dijkstra/Floyd Warshall       Euler Trail/Circuit       Heavy-Light Decomposition       Minimum Spanning Tree       Stable Marriage Problem       Trees       Directed Minimum Spanning Tree       Flow/Matching           Graph Matching               Bipartite Matching               Hopcroft–Karp Bipartite Matching               Weighted Bipartite Matching/Hungarian Algorithm           Flow               Max Flow/Min Cut               Min Cost Max Flow   DFS-like       Backtracking with Pruning/Branch and Bound       Basic Recursion       IDA* Search       Parsing/Grammar       Breadth First Search/Depth First Search       Advanced Search Techniques           Binary Search/Bisection           Ternary Search   Geometry       Basic Geometry       Computational Geometry       Convex Hull       Pick's Theorem   Game Theory       Green Hackenbush/Colon Principle/Fusion Principle       Nim       Sprague-Grundy Number   Matrix       Gaussian Elimination       Matrix Exponentiation   Data Structures       Basic Data Structures       Binary Indexed Tree       Binary Search Tree       Hashing       Orthogonal Range Search       Range Minimum Query/Lowest Common Ancestor       Segment Tree/Interval Tree       Trie Tree       Sorting       Disjoint Set   String       Aho Corasick       Knuth-Morris-Pratt       Suffix Array/Suffix Tree   Math       Basic Math       Big Integer Arithmetic       Number Theory           Chinese Remainder Theorem           Extended Euclid           Inclusion/Exclusion           Modular Arithmetic       Combinatorics           Group Theory/Burnside's lemma           Counting       Probability/Expected Value   Others       Tricky       Hardest       Unusual       Brute Force       Implementation       Constructive Algorithms       Two Pointer       Bitmask       Beginner       Discrete Logarithm/Shank's Baby-step Giant-step Algorithm       Greedy       Divide and Conquer   Dynamic Programming                       Tag it!

It was time for the 7th Nordic Cinema Popcorn Convention, and this year the manager Ian had a brilliant idea. In addition to the traditional film program, there would be a surprise room where a small group of people could stream a random movie from a large collection, while enjoying popcorn and martinis.

However, it turned out that some people were extremely disappointed, because they got to see movies like Ghosts of Mars, which instead caused them to tear out their hair in despair and horror.

To avoid this problem for the next convention, Ian has come up with a solution, but he needs your help to implement it. When the group enters the surprise room, they will type in a list of movies in a computer. This is the so-called horror list, which consists of bad movies that no one in the group would ever like to see. Of course, this list varies from group to group.

You also have access to the database Awesome Comparison of Movieswhich tells you which movies are directly similar to which. You can assume that movies that are similar to bad movies will be almost as bad. More specificly, we define the Horror index as follows:

Input

 

The first line of input contains three positive integers  N ,  H ,  L  ( 1≤H<N≤1000,0≤L≤10000 ), where  N  is the number of movies (represented by IDs, ranging from  0  to  N−1 ),  H  is the number of movies on the horror list and  L  is the number of similarities in the database.

The second line contains  H  unique space-separated integers  xi  ( 0≤xi < N ) denoting the ID of the movies on the horror list.

The following  L  lines contains two space-separated integers  ai , b i  ( 0≤ai < b i < N ), denoting that movie with ID  ai  is similar to movie with ID  bi  (and vice verca).

 

 

Output

Output the ID of the best movie in the collection (highest Horror Index). In case of a tie, output the movie with the lowest ID.

 

Sample Input

6 3 5
0 5 2
0 1
1 2
4 5
3 5
0 2

 

Sample Output

1

 

Source

The 2012 Nordic Collegiate Programming Contest

Prev  Submit  Status  Statistics  Discuss  Next

算法：最短路 =_= !

题意+思路：

我等英语弱菜实在是伤不起Orz

有 N 场电影【编号从 0 到 N-1】 背景懒得写了，说出来都是泪。。。

大致意思就是给你一张表上面有 H 个恐怖电影的标号。

然后给你  L  对关系，a, b 表示 a 和 b 相似。。。。【注意关系是双向的，也就意味着是个无向图】

然后题目的关键来了

根据上图中的公式，求出每个电影的恐怖值。。。

PS：最终你会发现，最恐怖的电影的价值应该是 0， 最不恐怖的反而尽量大。。。这一点很容易搞反。

第一行 HI = 0 ：表示在恐怖表中的电影，恐怖值均为 0 ，而且不会被其他的关系定义覆盖。【相当于以这些电影为起点】

第二行 HI = Q+1：如果和当前电影类似的最恐怖的电影的恐怖值是 Q ，那么当前电影的 HI = Q+1 

                            【相当于起点到当前电影的最小距离】

第三行 HI = INF ：如果当前电影不和任何电影相似。【表示是孤立的点,最不恐怖的电影】

一般的大多是正常人，为了不把自己吓的抓狂，当然是选择不怎么恐怖的电影看了，这里为了尽量满足大多数人的需求，当然是选择最不恐怖的电影了。如果恐怖度一样，就选择编号最小的电影。

那么题目就转化成了求 HI 最大的，电影编号，如果有多个一样，则输出最小的。PS：如果有INF的，当然直接输出最小的编号就over了

相当于以恐怖名单上的电影编号为起点，d[index] = 0; 如果 index 出现在恐怖名单上【样例中的第二行】

然后每一个点【电影】为终点，求出起点集合到终点的最短距离。

最后输出最短距离中距离最大的那个。。。

不知道说清楚了没有，反正比赛的时候我是没有想明白的，完了听Orc 提别人说是最短路才反应过来。。。

code：

代码丑了点Orz。。。。

不熟悉邻接表的优先队列实现还是个硬伤!!!

//PS:用邻接矩阵写的一个比较丑的代码,还是不习惯用邻接表写。。。等熟悉了再折腾吧
#include<stdio.h>
#include<string.h>
#include<algorithm>
#include<iostream>
using namespace std;

const int maxnN = 1000+10;
const int maxnL = 10000+10;
const int INF = 9999999;
int n,h,L;

int d[maxnN];
int w[maxnN][maxnN];
int vis[maxnN];

void Dijkstra()
{
    memset(vis, 0, sizeof(vis));
    for(int i = 0; i < n; i++)
    {
        int x , m = INF;
        for(int y = 0; y < n; y++) if(!vis[y] && d[y] <= m) m = d[x=y];
        if(m == INF) return; //如果存在孤立的点,不用继续判断
        vis[x] = 1;
        for(int y = 0; y < n; y++)
            d[y] = min(d[y], d[x]+w[x][y]);
    }
}
int main()
{
    while(scanf("%d%d%d", &n,&h,&L) != EOF)
    {
        for(int i = 0; i < n; i++) d[i] = INF; //初始化每一条边,都没有相邻的

        for(int i = 0; i < n; i++)
            for(int j = 0; j < n; j++)
                w[i][j] = (i == j ? 0 : INF);
        int x;
        for(int i = 0; i < h; i++)
        {
            scanf("%d", &x);
            d[x] = 0; //在恐怖表中的电影
        }

        int a,b;
        for(int i = 0; i < L; i++)
        {
            scanf("%d%d", &a,&b);
            w[a][b] = 1; //双向图
            w[b][a] = 1;
        }
        Dijkstra();

        int Max = d[0]; //从第一个开始查找
        int index = 0;
        for(int i = 1; i < n; i++)
        {
            if(d[i] > Max)
            {
                Max = d[i];
                index = i;
            }
        }
        printf("%d\n", index);
        //for(int i = 0; i < n; i++) printf("%d ", d[i]); printf("\n");
    }
    return 0;
}