Submission #142494

#	Time	Username	Problem	Language	Result	Execution time	Memory
142494		cookiedoth	Remittance (JOI19_remittance)	C++14	100 / 100	547 ms	44560 KiB

remittance

/*

Code for problem B by cookiedoth
Generated 01 Aug 2019 at 02.00 P


СТРОИМ СТЕНУ РАБОТЯГИ!
█▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀█
█═╩═╦═╩═╦═╩═╦═╩═╦═╩═╦═╩═╦═╩═█
█═╦═╩═╦═╩═╦═╩═╦═╩═╦═╩═╦═╩═╦═█
█═╩═╦═╩═╦═╩═╦═╩═╦═╩═╦═╩═╦═╩═█
█═╦═╩═╦═╩═╦═╩═╦═╩═╦═╩═╦═╩═╦═█
█═╩═╦═╩═╦═╩═╦═╩═╦═╩═╦═╩═╦═╩═█
█═╦═╩═╦═╩═╦═╩═╦═╩═╦═╩═╦═╩═╦═█
█═╩═╦═╩═╦═╩═╦═╩═╦═╩═╦═╩═╦═╩═█
█═╦═╩═╦═╩═╦═╩═╦═╩═╦═╩═╦═╩═╦═█
█▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄█

o_O
-_-
~_^

*/

#include <iostream>
#include <fstream>
#include <vector>
#include <set>
#include <map>
#include <bitset>
#include <algorithm>
#include <iomanip>
#include <cmath>
#include <ctime>
#include <functional>
#include <unordered_set>
#include <unordered_map>
#include <string>
#include <queue>
#include <deque>
#include <stack>
#include <complex>
#include <cassert>
#include <random>
#include <cstring>
#include <numeric>
#define ll long long
#define ld long double
#define null NULL
#define all(a) a.begin(), a.end()
#define debug(a) cerr << #a << " = " << a << endl
#define forn(i, n) for (int i = 0; i < n; ++i)
#define sz(a) (int)a.size()

using namespace std;

template<class T> int chkmax(T &a, T b) {
	if (b > a) {
		a = b;
		return 1;
	}
	return 0;
}

template<class T> int chkmin(T &a, T b) {
	if (b < a) {
		a = b;
		return 1;
	}
	return 0;
}

template<class iterator> void output(iterator begin, iterator end, ostream& out = cerr) {
	while (begin != end) {
		out << (*begin) << " ";
		begin++;
	}
	out << endl;
}

template<class T> void output(T x, ostream& out = cerr) {
	output(x.begin(), x.end(), out);
}

void fast_io() {
	ios_base::sync_with_stdio(0);
	cin.tie(0);
	cout.tie(0);
}

/** Fast input-output */

template <class T = int> inline T readInt();						
inline double readDouble();
inline int readUInt();					 
inline int readChar(); // first non-blank character
inline void readWord(char *s); 
inline bool readLine(char *s); // do not save '\n'
inline bool isEof();
inline int getChar(); 
inline int peekChar();
inline bool seekEof();
inline void skipBlanks();

template <class T> inline void writeInt(T x, char end = 0, int len = -1);
inline void writeChar(int x); 
inline void writeWord(const char *s);
inline void writeDouble(double x, int len = 0);
inline void flush();

static struct buffer_flusher_t {
	~buffer_flusher_t() {
		flush();
	}
} buffer_flusher;

/** Read */

static const int buf_size = 4096;

static unsigned char buf[buf_size];
static int buf_len = 0, buf_pos = 0;

inline bool isEof() {
	if (buf_pos == buf_len) {
		buf_pos = 0, buf_len = fread(buf, 1, buf_size, stdin);
		if (buf_pos == buf_len)
			return 1;
	}
	return 0;
}

inline int getChar() { 
	return isEof() ? -1 : buf[buf_pos++];
}

inline int peekChar() { 
	return isEof() ? -1 : buf[buf_pos];
}

inline bool seekEof() { 
	int c;
	while ((c = peekChar()) != -1 && c <= 32)
		buf_pos++;
	return c == -1;
}

inline void skipBlanks() {
	while (!isEof() && buf[buf_pos] <= 32U)
		buf_pos++;
}

inline int readChar() {
	int c = getChar();
	while (c != -1 && c <= 32)
		c = getChar();
	return c;
}

inline int readUInt() {
	int c = readChar(), x = 0;
	while ('0' <= c && c <= '9')
		x = x * 10 + c - '0', c = getChar();
	return x;
}

template <class T>
inline T readInt() {
	int s = 1, c = readChar();
	T x = 0;
	if (c == '-')
		s = -1, c = getChar();
	else if (c == '+')
		c = getChar();
	while ('0' <= c && c <= '9')
		x = x * 10 + c - '0', c = getChar();
	return s == 1 ? x : -x;
}

inline double readDouble() {
	int s = 1, c = readChar();
	double x = 0;
	if (c == '-')
		s = -1, c = getChar();
	while ('0' <= c && c <= '9')
		x = x * 10 + c - '0', c = getChar();
	if (c == '.') {
		c = getChar();
		double coef = 1;
		while ('0' <= c && c <= '9')
			x += (c - '0') * (coef *= 1e-1), c = getChar();
	}
	return s == 1 ? x : -x;
}

inline void readWord(char *s) { 
	int c = readChar();
	while (c > 32)
		*s++ = c, c = getChar();
	*s = 0;
}

inline bool readLine(char *s) { 
	int c = getChar();
	while (c != '\n' && c != -1)
		*s++ = c, c = getChar();
	*s = 0;
	return c != -1;
}

/** Write */

static int write_buf_pos = 0;
static char write_buf[buf_size];

inline void writeChar(int x) {
	if (write_buf_pos == buf_size)
		fwrite(write_buf, 1, buf_size, stdout), write_buf_pos = 0;
	write_buf[write_buf_pos++] = x;
}

inline void flush() {
	if (write_buf_pos) {
		fwrite(write_buf, 1, write_buf_pos, stdout), write_buf_pos = 0;
		fflush(stdout);
	}
}

template <class T> 
inline void writeInt(T x, char end, int output_len) {
	if (x < 0)
		writeChar('-'), x = -x;

	char s[24];
	int n = 0;
	while (x || !n)
		s[n++] = '0' + x % 10, x /= 10;
	while (n < output_len)
		s[n++] = '0';
	while (n--)
		writeChar(s[n]);
	if (end)
		writeChar(end);
}

inline void writeWord(const char *s) {
	while (*s)
		writeChar(*s++);
}

inline void writeDouble(double x, int output_len) {
	if (x < 0)
		writeChar('-'), x = -x;
	int t = (int)x;
	writeInt(t), x -= t;
	writeChar('.');
	for (int i = output_len - 1; i > 0; i--) {
		x *= 10;
		t = std::min(9, (int)x);
		writeChar('0' + t), x -= t;
	}
	x *= 10;
	t = std::min(9, (int)(x + 0.5));
	writeChar('0' + t);
}

int normalize(vector<int> &a) {
	for (int i = 0; i < a.size(); ++i) {
		if (i == (int)a.size() - 1) {
			if (a[i] < 0) {
				for (int j = 0; j < a.size(); ++j) {
					a[j] = -a[j];
				}
				normalize(a);
				return -1;
			}
			if (a[i] > 1) {
				a.push_back(0);
			}
		}
		if (a[i] < 0) {
			int cnt = abs((a[i] - 1) / 2);
			a[i] += 2 * cnt;
			a[i + 1] -= cnt;
		}
		if (a[i] >= 2) {
			int cnt = a[i] / 2;
			a[i] -= 2 * cnt;
			a[i + 1] += cnt;
		}
	}
	while (a.size() > 1 && a.back() == 0) {
		a.pop_back();
	}
	return 1;
}

vector<int> multiply(vector<int> &a, vector<int> &b) {
	vector<int> res((int)a.size() + (int)b.size() - 1);
	for (int j = 0; j < b.size(); ++j) {
		if (b[j]) {
			for (int i = 0; i < a.size(); ++i) {
				res[i + j] += a[i];
			}
		}
	}
	normalize(res);
	return res;
}

int smaller_or_eq(vector<int> &a, vector<int> &b) {
	if (a.size() < b.size()) {
		return 1;
	}
	if (a.size() > b.size()) {
		return 0;
	}
	for (int i = (int)a.size() - 1; i >= 0; --i) {
		if (a[i] > b[i]) {
			return 0;
		}
		if (a[i] < b[i]) {
			return 1;
		}
	}
	return 1;
}

vector<int> divide(vector<int> &a, vector<int> &b, int bits) {
	/*cerr << "divide" << endl;
	output(all(a));
	output(all(b));*/
	vector<int> res(bits), mult;
	for (int i = bits - 1; i >= 0; --i) {
		res[i] = 1;
		mult = multiply(b, res);
		if (!smaller_or_eq(mult, a)) {
			res[i] = 0;
		}
		else {
			//cerr << "put " << i << endl;
			//output(all(mult));
		}
	}
	mult = multiply(b, res);
	if (mult != a) {
		return vector<int> ();
	}
	normalize(res);
	return res;
}

const int mx = 1e6 + 228;
int n;
ll sum_a, sum_b, d[mx], x[mx];

void yes() {
	writeWord("Yes\n");
	exit(0);
}

void no() {
	writeWord("No\n");
	exit(0);
}

const int IQ = 35;

signed main() {
	fast_io();
	n = readInt();
	for (int i = 0; i < n; ++i) {
		ll ai, bi;
		ai = readInt();
		bi = readInt();
		sum_a += ai;
		sum_b += bi;
		d[i] = bi - ai;
	}
	if (sum_b == 0) {
		if (sum_a == 0) {
			yes();
		}
		no();
	}
	//output(d, d + n);
	vector<int> vd(d, d + n);
	int sign = normalize(vd);
	//output(all(vd));
	vector<int> zero = {0};
	if (sign == 1 && vd != zero) {
		no();
	}

	vector<int> to_divide(n, 1);
	vector<int> res = divide(vd, to_divide, IQ);
	if (res.empty()) {
		no();
	}
	//output(all(res));
	for (int i = 0; i < IQ; ++i) {
		x[0] += (1LL << i) * (ll)res[i];
	}
	for (int i = n - 1; i >= 1; --i) {
		x[i] = d[i] + 2 * x[(i + 1) % n];
	}
	for (int i = 0; i < n; ++i) {
		if (x[i] < 0) {
			no();
		}
	}
	yes();
}

Compilation message (stderr)

remittance.cpp: In function 'int normalize(std::vector<int>&)':
remittance.cpp:268:20: warning: comparison between signed and unsigned integer expressions [-Wsign-compare]
  for (int i = 0; i < a.size(); ++i) {
                  ~~^~~~~~~~~~
remittance.cpp:271:23: warning: comparison between signed and unsigned integer expressions [-Wsign-compare]
     for (int j = 0; j < a.size(); ++j) {
                     ~~^~~~~~~~~~
remittance.cpp: In function 'std::vector<int> multiply(std::vector<int>&, std::vector<int>&)':
remittance.cpp:300:20: warning: comparison between signed and unsigned integer expressions [-Wsign-compare]
  for (int j = 0; j < b.size(); ++j) {
                  ~~^~~~~~~~~~
remittance.cpp:302:22: warning: comparison between signed and unsigned integer expressions [-Wsign-compare]
    for (int i = 0; i < a.size(); ++i) {
                    ~~^~~~~~~~~~

• Subtask 1: 15 / 15
• Subtask 2: 40 / 40
• Subtask 3: 45 / 45