hdu 5183. Negative and Positive （哈希表）

Negative and Positive (NP)

Time Limit: 3000/1500 MS (Java/Others)    Memory Limit: 65536/65536 K (Java/Others)
Total Submission(s): 2177    Accepted Submission(s): 556

Problem Description

When given an array (a0,a1,a2,⋯an−1) and an integer K, you are expected to judge whether there is a pair (i,j)(0≤i≤j<n) which makes that NP−sum(i,j) equals to K true. Here NP−sum(i,j)=ai−ai+1+ai+2+⋯+(−1)j−iaj

 

 

Input

Multi test cases. In the first line of the input file there is an integer T indicates the number of test cases.
In the next 2∗T lines, it will list the data for each test case.
Each case occupies two lines, the first line contain two integers n and K which are mentioned above.
The second line contain (a0,a1,a2,⋯an−1)separated by exact one space.
[Technical Specification]
All input items are integers.
0<T≤25,1≤n≤1000000,−1000000000≤ai≤1000000000,−1000000000≤K≤1000000000

 

 

Output

For each case，the output should occupies exactly one line. The output format is Case #id: ans, here id is the data number starting from 1; ans is “Yes.” or “No.” (without quote) according to whether you can find (i,j) which makes PN−sum(i,j) equals to K.
See the sample for more details.

 

 

Sample Input

2

1 1

1

2 1

-1 0

 

 

Sample Output

Case #1: Yes. Case #2: No.

Hint

If input is huge, fast IO method is recommended.

 

 

Source

BestCoder Round #32

 

#include<stdio.h>
#include<string.h>
typedef long long ll ;
const int mod = 1000000 + 3 ;
int a[mod] ;
ll sum[mod] ;
int n , k ;

struct edge
{
    int nxt ;
    int node ;
}e[mod];
int head[mod] , top ;

void init ()
{
    memset (head , 0 , sizeof(head)) ;
    top = 0 ;
}

void insert (ll x)
{
    int y = x % mod ;
    if (y < 0)
        y += mod ;
    e[++top].nxt = head[y] ;
    e[top].node = x ;
    head[y] = top ;
}

bool find (ll x)
{
    int y = x % mod ;
    if (y < 0)
        y += mod ;
    for (int i = head[y] ; i ; i = e[i].nxt) {
        if (e[i].node == x)
            return true ;
    }
    return false ;
}

int main ()
{
    //freopen ("a.txt" , "r" , stdin) ;
    int T ;
    scanf ("%d" , &T) ;
    int ans = 0 ;
    while (T--) {
        scanf ("%d%d" , &n , &k) ;
        for (int i = 1 ; i <= n ; i++) {
            scanf ("%d" , &a[i]) ;
        }
        sum[0] = 0 ;
        for (int i = 1 ; i <= n ; i++) {
            if (i & 1)
                sum[i] = sum[i - 1] + a[i] ;
            else
                sum[i] = sum[i - 1] - a[i] ;
        }
        init () ;
        bool flag = 0 ;
        for (int i = n ; i > 0 && !flag ; i--) {
            insert (sum[i]) ;
            ll w ;
            if (i & 1)
                w = sum[i - 1] + k ;
            else
                w = sum[i - 1] - k ;
            if (find (w))
                flag = true ;
        }
        if (flag)
            printf ("Case #%d: Yes.
" , ++ans ) ;
        else
            printf ("Case #%d: No.
" , ++ans ) ;
    }
    return 0 ;
}

 第一次遇到哈希表，它能把查找一个数的复杂度降到0（1） 。

我学会的那种写法是通过“ 前向星 ”实现的，

他通过对插入数取余把数字存到数组中，从而防止了carsh ， nxt记录的是上一个和当前输入的数 取余 后相等的数 在 数组中的下标。

这道题思路：

sum[i] = a0 －　ａ１……　（－１）＾ｎ*an ;

将他们存入哈希表中

然后从n~1寻找哈希表中是否有sum[i] + k

 ps:另外用lower_bound + sort也能办到