Anyone has any tests for WA #6? I am out of ideas already. The problem seems too simple...

Getting WA#11, give some tests pls

When do we go from one-dimensional array to two-dimensional? This will be so rad!

//#pragma GCC optimize("Ofast,no-stack-protector")
//#pragma GCC target("avx")
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>

using namespace __gnu_pbds;
using namespace std;

#define re return
#define pb push_back
#define eb emplace_back
#define all(x) (x).begin(), (x).end()
#define fi first
#define se second
#define sqrt(x) sqrt(abs(x))
#define mp make_pair
#define pi (3.14159265358979323846264338327950288419716939937510)
#define fo(i, n) for(int i = 0; i < n; ++i)
#define ro(i, n) for(int i = n - 1; i >= 0; --i)
#define unique(v) v.resize(unique(all(v)) - v.begin())

template <class T> T abs (T x) { re x > 0 ? x : -x; }
template <class T> T sqr (T x) { re x * x; }
template <class T> T gcd (T a, T b) { re a ? gcd (b % a, a) : b; }
template <class T> int sgn (T x) { re x > 0 ? 1 : (x < 0 ? -1 : 0); }

typedef vector<int> vi;
typedef vector<vi> vvi;
typedef pair<int, int> ii;
typedef vector<ii> vii;
typedef vector<string> vs;
typedef double D;
typedef long double ld;
typedef long long ll;
typedef pair<ll, ll> pll;
typedef vector<ll> vll;
typedef unsigned long long ull;
typedef tree <pair<int, char>, null_type, less<pair<int, char>>, rb_tree_tag, tree_order_statistics_node_update> _tree;

const int maxn = (int) 1e5;
int a[maxn];

int main() {
    int n;
    scanf("%d", &n);
    fo(i, n) scanf("%d", a + i);
    int p1, p2;
    scanf("%d%d", &p1, &p2);
    --p1, --p2;
    if (p1 == p2) {
        int sum1 = 0, sum2 = 0;
        fo(i, p1) sum1 += a[i];
        for (int j = p1 + 1; j < n; ++j) sum2 += a[j];
        cout << max(sum1, sum2) + a[p1] << ' '<< min(sum1, sum2) << endl;
        re 0;
    }
    bool _swap = p1 > p2;
    if (p1 > p2) swap(p1, p2);
    int middle = p1 + (p2 - p1 - 1) / 2 + (((p2 - p1 - 1) & 1) && !_swap);
    ll sum1 = 0, sum2 = 0;
    fo(i, n) {
        if (i <= middle) sum1 += a[i];
        else sum2 += a[i];
    }
    if (_swap) swap(sum1, sum2);
    cout << sum1 << ' '<< sum2 << endl;
}

Plesae! Give me some tests for check my program.

To play optimally, both players would first move towards each other and then from the point of their intersection they will take all the numbers from that point to their nearest boundaries.
Let Player 1 start from X and Player 2 start from Y.
Then,
if (X < Y), player 1 will take all the numbers from A[1] to A[X] and player 2 will take all the numbers from A[Y] to A[N] and also player 1 will take the numbers from A[X] to A[(X+Y)/2] and player 2 will take the numbers from A[(X+Y)/2+1] to A[Y].
if (X > Y) same as above but now player 1 will work from X to N and player 2 will work from 1 to Y.
if (X == Y), calculate the sum from A[1] to A[X-1] and another sum from A[X+1] to A[N],
add A[X] to the greater sum and give it to player 1.

I can't pass test 4, I just can't,,,,,


thanks,, problem founded....

Edited by author 29.11.2013 11:03

All my tests are working, but on the server WA 2??! Help! Give me some tests...please!

существует ли способ записи данных в массив без использования строк??

any ideas on WA11 (solution passes all the tests posted here in discussions) ?

I was trying to solve this and I kinda mis-understood in the first place, which makes the problem hard to solve.

If the player can decide on the first move (just the first move), then it would be much more complex.

For example,
5
1 2 3 4 5
3 3

The current answer is 12 3 because the first player takes 3, 4, 5 and the second player takes 0 2 1

However, if we allow players to skip their first pick, in other words, (move and pick) instead of (pick and move). So there are few more possibilities.

if first player picks 3, then the second player can pick 4 and 5  ==> 6, 9
if the first player picks 4, then the second player can pick 3, 2 and 1  ==> 9, 6

maybe I think too much ?
:)

First of all, yes, the two players can be in the same cell, even at the beginning of the game. That only means that the first player that arrived there will take its value.
Test:
5
1 2 3 4 5
1 1
Answer:
15 0

Test:
5
1 2 3 4 5
5 5
Answer:
15 0

If they both start from the same position, who eats the number from that position?

My algorithm finds the numbers on the left and right, and then compares them, and takes a step toward greater. But if the sum is equal, it compares to one until it finds one larger (and goes upwards). If comparing the results in one step, then goes in the direction of the enemy.

What's wrong?

"Each player has his own specified starting position", means that the starting positions of the players is different?

"At some moment of time two players can be located in the same cell."
If this occurs, who will take the number in that cell?
If both of them can take,then they can meet at some point and simultaneously take the number.That will maximize their score.