Codeforces 682B贪心

这题是一道不太典型的贪心题目。题目的链接如下：
http://codeforces.com/problemset/problem/682/B

B. Alyona and Mex
time limit per test1 second
memory limit per test256 megabytes
inputstandard input
outputstandard output
Someone gave Alyona an array containing n positive integers a1, a2, …, an. In one operation, Alyona can choose any element of the array and decrease it, i.e. replace with any positive integer that is smaller than the current one. Alyona can repeat this operation as many times as she wants. In particular, she may not apply any operation to the array at all.

Formally, after applying some operations Alyona will get an array of n positive integers b1, b2, …, bn such that 1 ≤ bi ≤ ai for every 1 ≤ i ≤ n. Your task is to determine the maximum possible value of mex of this array.

Mex of an array in this problem is the minimum positive integer that doesn’t appear in this array. For example, mex of the array containing 1, 3 and 4 is equal to 2, while mex of the array containing 2, 3 and 2 is equal to 1.

Input
The first line of the input contains a single integer n (1 ≤ n ≤ 100 000) — the number of elements in the Alyona’s array.

The second line of the input contains n integers a1, a2, …, an (1 ≤ ai ≤ 109) — the elements of the array.

Output
Print one positive integer — the maximum possible value of mex of the array after Alyona applies some (possibly none) operations.

Examples
input
5
1 3 3 3 6
output
5
input
2
2 1
output
3
Note
In the first sample case if one will decrease the second element value to 2 and the fifth element value to 4 then the mex value of resulting array 1 2 3 3 4 will be equal to 5.

To reach the answer to the second sample case one must not decrease any of the array elements.

这题的意思就是给你一串数字，然后求没有出现过得最小的数的最大可能,这样说可能不太明白，就是给你一串数字，然后你可以让它减小，然后求不能连续到达的第一个整数。

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <string>
#include <algorithm>
using namespace std;

int main()
{
    long long a[100001];
    int n ;
    int flag ;
    while(cin >> n){
        flag = 0 ;
        for(int i = 0 ; i < n ; i++)
            cin >> a[i];
        sort(a, a+n);//先对整个数组从小到大排序
        for(int i = 0 ; i < n ; i++)
            if(flag < a[i])
                flag++;/*flag就是能够连续访问的最大的值然后
     然后如果它不大于数组的值（数组的值能够减小）所以他能够继续访问
     这个值，所以当flag不大于a[i]时，对flag++*/
        cout << flag+1 << endl ;
    }
    return 0 ;
}