Ideone.com

download

copy

#include <bits/stdc++.h>
 
using namespace std;
 
const int N = 105;
int n;
int a[N];
// memo array is used for memoization of function isWinning
int memo[N][N];
 
// memo1 array is used for memoization of function probWinning
double memo1[N][N];
 
// Here g denotes the current gcd in the game. taken denotes how many numbers are taken out of the game, ie how many numbers
// have been thrown out.
// This function returns whether the state denotes by (g, taken) is winning or not?
int isWinning (int g, int taken) {
      int &res = memo[g][taken];
      // memoization step.
      // if res is negative (meaning that we have not computed the answer corresponding to (g, taken) state, we need to compute that), then we will
      // do the processing of that state.
      // otherwise, we will simply return the answer.
      if (res == -1) {
            res = 0;
            // if all the numbers has been taken out, it means there is no more numbers to play with.
            // hence the person playing this turn will lose because he wont be able to make any move.
            if (taken == n) {
                  res = 0;
            } else {
                  // tot denotes number of multiples of g in the array a.
                  int tot = 0;
                  for (int i = 0; i < n; i++) if (__gcd(g, a[i]) == g) tot++;
 
                  // if not all multiples of g are thrown out, it means that there are still multiples of g currently in the array a.
                  // we can use them in the game. gcd is not going to change being the number we are going to take will be multiple of g.
                  // as gcd (g, t) = g if t = k * g (ie t is a multiple of g).
                  if (taken < tot) {
                        if (taken < tot && !isWinning(g, taken + 1)) {
                              res = 1;
                        }
                  }
 
                  // if have already won, no need to process the remaining the states. This is simply a pruning step, wont have much effect on the
                  // overall complexity. You can chose to run this step too.
                  if (res == 0) {
                        // Now we will iterate over the numbers which are having gcd with g not equal to 1 (because we will lose in that case) and
                        // not equal to g because we have already considered that case before.
                        for (int i = 0; i < n; i++) {
                              if (__gcd (g, a[i]) > 1) {
                                    if (__gcd(g, a[i]) == g) {
                                          continue;
                                          // this case has been already considered before.
                                    } else {
                                          if (!isWinning(__gcd(g, a[i]), taken + 1)) {
                                                res = 1;
                                                break;
                                          }
                                    }
                              }
                        }
                  }
            }
      }
      return res;
}
 
// Here g denotes the current gcd in the game. taken denotes how many numbers are taken out of the game, ie how many numbers
// have been thrown out.
// function returns the probability of winning if I am at state denoted by (g, taken).
double probWinning (int g, int taken) {
      double &res = memo1[g][taken];
      // memoization step.
      // if res is negative (meaning that we have not computed the answer corresponding to (g, taken) state, we need to compute that), then we will
      // do the processing of that state.
      // otherwise, we will simply return the answer.
 
      if (res <= -0.5) {
            if (g == 1) {
                  // if gcd is 1, it means that other person has made the move and has made the gcd equal to 1, Hence other person is losing.
                  // that means that player at the current step is winning. So probability of winning = 1.
                  res = 1.0;
            } else {
                  res = 0;
                  if (taken == n) {
                        res = 0;
                  } else {
                        // tot denotes number of multiples of g in the array a.
                        int tot = 0;
                        for (int i = 0; i < n; i++) if (__gcd(g, a[i]) == g) tot++;
 
                        // this is an important step to pay attention to.
                        // we have currently taken element thrown out of the game, we have tot elements which are multiples of g.
                        // hence there are still tot - taken elements which are multiples of g.
                        // we can chose any one of them with equal probability.
                        // probability of chosing one of them will be equal to (tot - taken) / (total elements that are not thrown).
                        // As total elements that are not thrown = n - taken.
                        // Hence probability of chosing one of them will be equal to (tot - taken) / (n - taken).
 
                        // Note that in this case, there wont be any change in gcd, it will remain g (because current element in consideration is multiple of g).
                        double res1 = 0;
                        if (taken < tot) {
                              res += (1 - probWinning(g, taken + 1)) * 1.0 * (tot - taken) / (n - taken);
                        }
 
                        // Now we will iterate over the numbers which are having gcd with g not equal to g because we have already considered that case before.
                        for (int i = 0; i < n; i++) {
                              if (__gcd(g, a[i]) == g) {
                                    // case already considered, nothing to do.
                                    continue;
                              } else {
                                    // You can make your current gcd to gcd(g, a[i]).
                                    // number of taken elements (or thrown elements) will increase by 1.
                                    // probability of a single case is 1 / (elements remaining) = 1 / (n - taken).
                                    res += (1 - probWinning(__gcd(g, a[i]), taken + 1)) * 1.0 / (n - taken);
                              }
                        }
 
                        // if your numbers becomes very small, it is better to make it equal to 0.
                        // sometimes it happens that your numbers keep on decreasing, then their processing of doubles in such small ranges becomes
                        // very expensive.
                        if (res < 1e-8)
                              res = 0;
                  }
            }
      }
      return res;
}
 
int main() {
      int T;
      cin >> T;
 
      while (T--) {
            cin >> n;
            int g = 0;
            for (int i = 0; i < n; i++) {
                  cin >> a[i];
                  g = __gcd(g, a[i]);
            }
 
            // if gcd g is > 1, then we can never make the game end with gcd = 1, because finally at the end gcd will be g and g > 1.
            // So in this case, both the players can keep moving until there are not any elements left.
            // So outcome of the game will be decided by parity directly.
            // if n is odd, it means that first player can pick the last number and second player will not have any option to move, Hence first player will win.
            // if n is even, then second player will win.
            // Note that in this case, even if game is played randomly, there wont be any effect on the outcome.
            if (g > 1) {
                  // dont forget to print exactly 4 digits after the decimal.
                  cout << n % 2 << " " << (n % 2) << ".0000" << endl;
                  continue;
            }
 
            // intiliaze memo array with -1, denoting state is not been processed yet.
            memset(memo, -1, sizeof(memo));
            int ok = false;
            if (isWinning(0, 0)) ok = true;
            if (ok) cout << 1 << " ";
            else cout << 0 << " ";
 
            // intiliaze memo1 array with -1, denoting state is not been processed yet.
            for (int i = 0; i < N; i++)
                  for (int j = 0; j < N; j++)
                              memo1[i][j] = -1.0;
 
            double res = probWinning(0, 0);
 
            // dont forget to print exactly 4 digits after the decimal.
            printf("%.4f\n", res);
      }
 
      return 0;
}

#include <bits/stdc++.h>

using namespace std;

const int N = 105;
int n;
int a[N];
// memo array is used for memoization of function isWinning
int memo[N][N];

// memo1 array is used for memoization of function probWinning
double memo1[N][N];

// Here g denotes the current gcd in the game. taken denotes how many numbers are taken out of the game, ie how many numbers
// have been thrown out.
// This function returns whether the state denotes by (g, taken) is winning or not?
int isWinning (int g, int taken) {
      int &res = memo[g][taken];
      // memoization step.
      // if res is negative (meaning that we have not computed the answer corresponding to (g, taken) state, we need to compute that), then we will
      // do the processing of that state.
      // otherwise, we will simply return the answer.
      if (res == -1) {
            res = 0;
            // if all the numbers has been taken out, it means there is no more numbers to play with.
            // hence the person playing this turn will lose because he wont be able to make any move.
            if (taken == n) {
                  res = 0;
            } else {
                  // tot denotes number of multiples of g in the array a.
                  int tot = 0;
                  for (int i = 0; i < n; i++) if (__gcd(g, a[i]) == g) tot++;

                  // if not all multiples of g are thrown out, it means that there are still multiples of g currently in the array a.
                  // we can use them in the game. gcd is not going to change being the number we are going to take will be multiple of g.
                  // as gcd (g, t) = g if t = k * g (ie t is a multiple of g).
                  if (taken < tot) {
                        if (taken < tot && !isWinning(g, taken + 1)) {
                              res = 1;
                        }
                  }

                  // if have already won, no need to process the remaining the states. This is simply a pruning step, wont have much effect on the
                  // overall complexity. You can chose to run this step too.
                  if (res == 0) {
                        // Now we will iterate over the numbers which are having gcd with g not equal to 1 (because we will lose in that case) and
                        // not equal to g because we have already considered that case before.
                        for (int i = 0; i < n; i++) {
                              if (__gcd (g, a[i]) > 1) {
                                    if (__gcd(g, a[i]) == g) {
                                          continue;
                                          // this case has been already considered before.
                                    } else {
                                          if (!isWinning(__gcd(g, a[i]), taken + 1)) {
                                                res = 1;
                                                break;
                                          }
                                    }
                              }
                        }
                  }
            }
      }
      return res;
}

// Here g denotes the current gcd in the game. taken denotes how many numbers are taken out of the game, ie how many numbers
// have been thrown out.
// function returns the probability of winning if I am at state denoted by (g, taken).
double probWinning (int g, int taken) {
      double &res = memo1[g][taken];
      // memoization step.
      // if res is negative (meaning that we have not computed the answer corresponding to (g, taken) state, we need to compute that), then we will
      // do the processing of that state.
      // otherwise, we will simply return the answer.

      if (res <= -0.5) {
            if (g == 1) {
                  // if gcd is 1, it means that other person has made the move and has made the gcd equal to 1, Hence other person is losing.
                  // that means that player at the current step is winning. So probability of winning = 1.
                  res = 1.0;
            } else {
                  res = 0;
                  if (taken == n) {
                        res = 0;
                  } else {
                        // tot denotes number of multiples of g in the array a.
                        int tot = 0;
                        for (int i = 0; i < n; i++) if (__gcd(g, a[i]) == g) tot++;

                        // this is an important step to pay attention to.
                        // we have currently taken element thrown out of the game, we have tot elements which are multiples of g.
                        // hence there are still tot - taken elements which are multiples of g.
                        // we can chose any one of them with equal probability.
                        // probability of chosing one of them will be equal to (tot - taken) / (total elements that are not thrown).
                        // As total elements that are not thrown = n - taken.
                        // Hence probability of chosing one of them will be equal to (tot - taken) / (n - taken).

                        // Note that in this case, there wont be any change in gcd, it will remain g (because current element in consideration is multiple of g).
                        double res1 = 0;
                        if (taken < tot) {
                              res += (1 - probWinning(g, taken + 1)) * 1.0 * (tot - taken) / (n - taken);
                        }

                        // Now we will iterate over the numbers which are having gcd with g not equal to g because we have already considered that case before.
                        for (int i = 0; i < n; i++) {
                              if (__gcd(g, a[i]) == g) {
                                    // case already considered, nothing to do.
                                    continue;
                              } else {
                                    // You can make your current gcd to gcd(g, a[i]).
                                    // number of taken elements (or thrown elements) will increase by 1.
                                    // probability of a single case is 1 / (elements remaining) = 1 / (n - taken).
                                    res += (1 - probWinning(__gcd(g, a[i]), taken + 1)) * 1.0 / (n - taken);
                              }
                        }

                        // if your numbers becomes very small, it is better to make it equal to 0.
                        // sometimes it happens that your numbers keep on decreasing, then their processing of doubles in such small ranges becomes
                        // very expensive.
                        if (res < 1e-8)
                              res = 0;
                  }
            }
      }
      return res;
}

int main() {
      int T;
      cin >> T;

      while (T--) {
            cin >> n;
            int g = 0;
            for (int i = 0; i < n; i++) {
                  cin >> a[i];
                  g = __gcd(g, a[i]);
            }

            // if gcd g is > 1, then we can never make the game end with gcd = 1, because finally at the end gcd will be g and g > 1.
            // So in this case, both the players can keep moving until there are not any elements left.
            // So outcome of the game will be decided by parity directly.
            // if n is odd, it means that first player can pick the last number and second player will not have any option to move, Hence first player will win.
            // if n is even, then second player will win.
            // Note that in this case, even if game is played randomly, there wont be any effect on the outcome.
            if (g > 1) {
                  // dont forget to print exactly 4 digits after the decimal.
                  cout << n % 2 << " " << (n % 2) << ".0000" << endl;
                  continue;
            }

            // intiliaze memo array with -1, denoting state is not been processed yet.
            memset(memo, -1, sizeof(memo));
            int ok = false;
            if (isWinning(0, 0)) ok = true;
            if (ok) cout << 1 << " ";
            else cout << 0 << " ";

            // intiliaze memo1 array with -1, denoting state is not been processed yet.
            for (int i = 0; i < N; i++)
                  for (int j = 0; j < N; j++)
                              memo1[i][j] = -1.0;

            double res = probWinning(0, 0);

            // dont forget to print exactly 4 digits after the decimal.
            printf("%.4f\n", res);
      }

      return 0;
}


Runtime error #stdin #stdout 0.16s 3476KB

stdin

copy

Standard input is empty

stdout

copy

https://ideone.com/CHxnq7

language:

C++14 (gcc 8.3)

created:

visibility:

public

Share or Embed source code

Discover > Sphere Engine API

The brand new service which powers Ideone!

Discover > IDE Widget

Widget for compiling and running the source code in a web browser!

Discover > Sphere Engine API

Discover > IDE Widget

Choose your language