So the task is to determine whether the sum C[n][1]+C[n][2]+...+C[n][k] is greater than X and do it FAST.
I can't do it fast.


#include <stdio.h>
typedef unsigned long long huge;
huge calc(int n, int k){
     huge Up=k, Dn=0;
     while(Up-Dn>1){
           huge Md=(Up+Dn)/2;
           huge cnt=0;
           long double aux=1;
           for(int i=1; cnt<k && i<=n; ++i){
                  aux*=(long double)Md+1-i;
                  aux/=i;
                  cnt+=aux;
           }
           if(cnt<k)
                Dn=Md;
           else
                Up=Md;
     }
     return Dn+1;
}
int main(){
    huge n,k, ans[1000];
    int tot=0;
    scanf("%llu %llu",&n,&k);
    while(n>0 && k>0){
         ans[tot++]=calc(n,k);
         scanf("%llu %llu",&n,&k);
    }
    for(int i=0; i<tot; ++i)
          printf("%llu\n",ans[i]);
    return 0;
}

Named         avg =5
High          avg>=4.5 not contain 3   nooooote  that
Common             not  3 and less than 4.5
None            not all of the above

I have implemented a greedy algorithm to solve this problem and it got accepted and after reading the discussion I have noticed that many people used Prims algorithm to solve.
I have no idea of what Prims algorithm is. Could anyone please tell me what exactly is my code doing and how is it different from Prims algorithm?

[code deleted]

Edited by moderator 21.01.2020 16:06

Obviously USED array is MLE.  Probably using unordered_set is OK. Are there better things than unordered_set?  Maybe there are some mathematical properties?..

(n+2)*((n+1)*n)/2

Calculate powers of 26 and prefix sums of powers of 26.
Calculate ranges by integer division.
Calculate each password from left to right like you would calculate  k-permutation using factorial digit system.

Set answer as (2+n).
Then n times repeat answer+="+one"in set(input()).
"+" in set(input ())  is also enough.

Create three dictionaries :
    used <boolean>
    connections <set<string>>
    distance <string>

Then import queue.
Then breadth - first search.

If a=1 then what?
For example
2
1 10
1 20

Who got AC, please, send your code to 'my_trashbox@mail.ru'

1.Use a DP with the O(30N) time
2.Use ternary (long long in C++ is needed) to indicate each solution
3.Use a rolling array in case it MLEs

Good luck! ~_~

Edited by author 05.07.2011 19:05

I have WA 7 and I don't understand what the problem is.
My tests:
// check(<input string #1>, <input string #2> as integer, <output string>)

      // tests from acm.timus
      check("10.23", 0, "10")
      check(".04", 1, "0.0")
      check("-0.051e0", 1, "0.0")
      check("1.1e30", 10, "1100000000000000000000000000000.0000000000")
      check("-1.1e-30", 1, "0.0")
      check("2468097632.1358642324268913e-2", 20, "24680976.32135864232426891300")
      check("e23", 3, "Not a floating point number")
      check("1 e3", 1, "Not a floating point number")

      // my tests
      check(" 1 e3", 1, "Not a floating point number")
      check("1e3", 1, "1000.0")
      // http://acm.timus.ru/forum/thread.aspx?id=26503&upd=634425663233423296
      // Posted by Igor Dex 1 Jun 2011 18:28
      // It is clear that we can't have leading spaces in case correct real number. But is it possible to have spaces after correct number till the end of the string?
      // Posted by AterLux 1 Jun 2011 23:05
      // No. Trailing as leading spaces not satisfy the syntactical description.
      check("   ", 1, "Not a floating point number")
      check(" ", 1, "Not a floating point number")
      check("-", 1, "Not a floating point number")
      check(" 1e3", 1, "Not a floating point number")
      check(" .1e3", 1, "Not a floating point number")
      check(".1e-3", 1, "0.0")
      check(" .1e-3 ", 1, "Not a floating point number")
      check(".1e-3 ", 1, "Not a floating point number")
      check(".0e-10000000000000000000", 1, "0.0")
      check(".0e+10000000000000000000", 1, "0.0")

      // int and uint tests
      check("10", 0, "10")
      check("10", 1, "10.0")
      check("-10", 1, "-10.0")
      check("+10", 1, "10.0")
      // simplefloat and usimplefloat tests
      check(".10", 1, "0.1")
      check("10.10", 1, "10.1")
      check("10.01", 1, "10.0")
      check("+.10", 1, "0.1")
      check("+10.10", 1, "10.1")
      check("+10.01", 1, "10.0")
      check("-.10", 1, "-0.1")
      check("-10.10", 1, "-10.1")
      check("-10.01", 1, "-10.0")
      // float tests
      check("10e0", 0, "10")
      check("10e-1", 1, "1.0")
      check("-10e+1", 1, "-100.0")
      check("+10e+3", 1, "10000.0")
      check(".10e-3", 1, "0.0")
      check("10.10e-1", 1, "1.0")
      check("10.01e-2", 1, "0.1")
      check("+.10e-10000", 1, "0.0")
      check("+10.10e-100", 1, "0.0")
      check("+10.01e1", 1, "100.1")
      check("-.10e1", 1, "-1.0")
      check("-10.10e-1", 1, "-1.0")
      check("-10.01e-2", 1, "-0.1")
      // "Not a floating point number" tests

      // But see http://acm.timus.ru/forum/thread.aspx?id=10235&upd=632909844439020000
      // Posted by Kopeliovitch Sergey (1) 30 Jul 2004 21:29
      // Segey say his progamm have AC with other answers, but right answers are
//Update: Now Segey have WA #1 and WA #12 and didn't have AC.
      check("10.", 1, "Not a floating point number")
      check("10.0e", 1, "Not a floating point number")
      check("10.e", 1, "Not a floating point number")

      //
      check("1E1 1", 1, "Not a floating point number")
      check("-+3", 1, "Not a floating point number")
      check("+", 1, "Not a floating point number")
      check("-", 1, "Not a floating point number")
      check(" ", 1, "Not a floating point number")
      check("-10.01ee", 1, "Not a floating point number")
      check("12.e10", 1, "Not a floating point number")
      check("-.e10", 1, "Not a floating point number")
      check("1e", 1, "Not a floating point number")
      check("e1", 1, "Not a floating point number")
      check("e", 1, "Not a floating point number")
      check("se-1", 1, "Not a floating point number")
      check("+e", 1, "Not a floating point number")
      check("-e1", 1, "Not a floating point number")
      check(".e4", 1, "Not a floating point number")
      check("0.", 1, "Not a floating point number")
      check("1e", 1, "Not a floating point number")
      check("0x123", 1, "Not a floating point number")
      check("1E2.1", 1, "Not a floating point number")
      check("-1E2.1", 1, "Not a floating point number")
      check("1E2.1e2", 1, "Not a floating point number")
      check("1e00-1", 0, "Not a floating point number")
      // # tests
      check("1#", 1, "Not a floating point number")
      check("#1", 1, "Not a floating point number")
      check("# 1", 1, "Not a floating point number")
      check("1 #", 1, "Not a floating point number")
      // big power test
      check("1e10", 1, "10000000000.0")
      check("1e10", 0, "10000000000")
      check("-1e10", 0, "-10000000000")
      check("1e-10", 0, "0")
      check("0e+10", 0, "0")
      check("0e+100", 0, "0")
      check("0e+10000000000000000000", 0, "0")
      check("0e-10000000000000000000", 0, "0")
      check("0e10000000000000000000", 0, "0")
      check("1e000000000000000000000000000000000000000000000000000000000000000000000000000000", 0, "1")
      check("1e000000000000000000000000000000000000000000000000000000000000000000000000000001", 0, "10")
      check("1e-000000000000000000000000000000000000000000000000000000000000000000000000000001", 0, "0")
      check("234565432452433e-10000000000000000000", 0, "0")
      check("-234565432452433e-10000000000000000000", 0, "0")

      // An integral part of a number should be non-empty.
      check(".1e+0", 1, "0.1")
      check("-.1e+0", 1, "-0.1")
      // There shouldn't be leading zeroes in a non-zero integral part of a number.
      // A zero integral part of a number should consist of an only zero.
      check("00000.1e+0", 1, "0.1")
      check("-00000.1e+0", 1, "-0.1")
      check("00001.1e+0", 1, "1.1")
      check("-00001.1e+0", 1, "-1.1")
      check("00001.1", 1, "1.1")
      check("-00001.1", 1, "-1.1")
      check("00001.1", 0, "1")
      check("-00001.1", 0, "-1")
      // A fractional part of a number should contain exactly N symbols.
      check("00001.1", 0, "1")
      check("00001.1", 3, "1.100")
      check("-00001.1", 1, "-1.1")
      // There shouldn't be a sign "+" before a positive number.
      check("+00001.1", 0, "1")
      check("+1.1", 0, "1")
      check("+1.1", 3, "1.100")
      check("+1.1e+1", 1, "11.0")
      // You shouldn't round off a number.
      check("+1.5e+1", 1, "15.0")
      check("+1.06", 1, "1.0")
      check("+1.6e-1", 1, "0.1")

Edited by author 29.03.2017 22:42

Edited by author 29.03.2017 22:47

Edited by author 30.03.2017 00:56

New anti-hash test was added. 141 author lost AC.

-------------------------
10 7
2 3 1 3 4 1 6 1 2 5
3 4 0
1 0
0
3 0
1 4 0
4 5 0
8 0
0
8 0
7 9 0
1
0
2 4 5 10 0

My AC answer:
18
3
4
8
1
2
5
7
9
10
-------------------------
5 7
1 1 1 1 1
2 0
3 0
4 0
5 0
1 0
1
0
1 2 0

My AC answer: No Solution

Good luck!

please give me some hints how to solve the problem fast

use unordered_map instead of map

int main(int argc,char *argv[]){
    //freopen("data.txt","r",stdin);
    int n,i,key = 0,count = 0;
    char p[105],input[105];
    scanf("%d",&n);
    getchar();
    for(i = 0; i < n; i++){
        scanf("%c",&input[i]);
        getchar();
    }
    input[i] = '\0';
    strcpy(p,input);
    while(next_permutation(p,p+n)){
        if(strcmp(p,input) == 0){
            break;
        }
        else {
            count++;
            if(count >= 5){
                printf("Yes\n");
                return 0;
            }
        }
    }
    if(count >= 5){
        printf("Yes\n");
    }
    else {
        printf("No\n");
    }
}

/*
ye mera template hai
apna khud likho bc :P
*/

/*
Author : Sarvagya Agarwal
*/

#include<bits/stdc++.h>
using namespace std;

//defines
#define openin freopen("input.txt","r",stdin)
#define openout freopen("output.txt","w",stdout)
#define fast ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0)
#define ll long long
#define int long long
#define mod 1000000007
#define repr(i,x,y) for (__typeof(x) i=x;i>=y;i--)
#define rep(i,x,y) for (__typeof(x) i=x;i<=y;i++)
#define all(c) (c).begin(),(c).end()
#define ff first
#define ss second
#define pb push_back
#define mp make_pair

/* Print pair */
template <typename T,typename S>
ostream & operator << (ostream &os , const pair<T,S> &v) {
    os << "(" ;
    os << v.first << "," << v.second << ")" ;
    return os ;
}
/* Print vector */
template <typename T>
ostream & operator << (ostream &os , const vector<T> &v) {
    os << "[" ;
    int sz = v.size() ;
    for(int i = 0 ; i < sz ; ++i) {
        os << v[i] ;
        if(i!=sz-1)os << "," ;
    }
    os << "]\n" ;
    return os ;
}
/* Print set */
template <typename T>
ostream & operator << (ostream &os , const set<T> &v) {
    T last = *v.rbegin() ;
    os << "[" ;
    for(auto it : v) {
        os << it  ;
        if(it != last) os << "," ;
    }
    os << "]\n" ;
    return os ;
}
/* Print Map */
template <typename T,typename S>
ostream & operator << (ostream &os , const map<T,S> &v) {
    for(auto it : v) {
        os << it.first << " : " << it.second << "\n" ;
    }
    return os ;
}
int power(int a , int b)
{
    int res = 1 ;
    while(b)
    {
        if(b%2) {
            res = (res * a) % mod ;
        }
        b/=2 ;
        a = (a*a) % mod ;
    }
    return res ;
}

//debug
#define TRACE

#ifdef TRACE
#define trace(...) __f(#__VA_ARGS__, __VA_ARGS__)
template <typename Arg1>
void __f(const char* name, Arg1&& arg1){
        cerr << name << " : " << arg1 << std::endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args){
        const char* comma = strchr(names + 1, ',');cerr.write(names, comma - names) << " : " << arg1<<" | ";__f(comma+1, args...);
}
#else
#define trace(...)
#endif
int sum , n , arr[105] ;
int dp[105][1005] ;
int ans[105] ;
int solve(int index,int weight)
{
    if(weight == 0) {
        // found a configuration
        return 1 ;
    }
    if(index > n) {
        return 0 ;
    }
    int &res = dp[index][weight] ;
    if(res != -1) return res ;
    res = 0 ;
    res += solve(index + 1 , weight) ;
    if(arr[index] <= weight)res += solve(index + 1 , weight - arr[index] ) ;
    return res ;
}
void go(int index, int weight)
{
    if(index > n || weight == 0) return ;
    // can you take this ?
    if(arr[index] <= weight && solve(index + 1 , weight - arr[index]) == 1) {
         ans[index] = 1 ;
         go(index + 1 , weight - arr[index] ) ;
         return ;
    }
    go(index + 1 , weight) ;
    return  ;
}
int32_t main()
{
    fast;
    cin >> sum >> n ;
    rep(i,1,n) {
        cin >> arr[i] ;
    }
    memset(dp,-1,sizeof(dp)) ;
    int res = solve(1,sum) ;
    if(res == 0) {
        cout << res ;
        return 0 ;
    }
    if(res > 1) {
        cout << -1 ;
        return 0 ;
    }
    go(1,sum) ;
    for(int i = 1 ; i <= n ; ++i) {
        if(ans[i] == 0) {
            cout << i << " " ;
        }
    }
    return 0;
}

Simply use DP with Recurse and You'll get AC!