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