text
stringlengths 49
983k
|
|---|
#include <bits/stdc++.h>
using namespace std;
//int dirs[4][2]={{-1,0},{1,0},{0,-1},{0,1}};
//int dirs[8][2]={{-1,0},{0,-1},{0,1},{1,0},{1,1},{-1,-1},{-1,1},{1,-1}};
long long modd=1e9+7;
vector<int> dsu;
vector<int> height;
vector<bool> has_loop;
int find_leader(int u)
{
if(dsu[u]==u) return u;
return dsu[u]=find_leader(dsu[u]);
}
void voeg_samen(int u, int v)
{
u=find_leader(u);
v=find_leader(v);
if(u==v) return;
if(height[u]>height[v])
{
dsu[v]=u;
if(has_loop[v]) has_loop[u]=true;
}
else if(height[u]<height[v])
{
dsu[u]=v;
if(has_loop[u]) has_loop[v]=true;
}
else
{
dsu[u]=v;
height[v]++;
if(has_loop[u]) has_loop[v]=true;
}
}
int main()
{
//ios::sync_with_stdio(false);
//freopen("inp.in","r",stdin);
//freopen("outp.out","w",stdout);
int n, m;
scanf("%d %d", &n, &m);
dsu.assign(m,-1);
has_loop.assign(m,false);
height.assign(m,0);
for(int i=0; i<m; i++)
{
dsu[i]=i;
}
vector<int> ans_indices;
for(int i=0; i<n; i++)
{
int k;
scanf("%d", &k);
if(k==1)
{
int u;
scanf("%d", &u);
u--;
int leader=find_leader(u);
if(has_loop[leader])
{
continue;
}
else
{
has_loop[leader]=true;
ans_indices.push_back(i);
}
}
else
{
int u, v;
scanf("%d %d", &u, &v);
u--;
v--;
int ld1=find_leader(u);
int ld2=find_leader(v);
//cerr << u << " " << v << endl;
//cerr << ld1 << " " << ld2 << " " << has_loop[ld1] << " " << has_loop[ld2] << endl;
if((has_loop[ld1]&&has_loop[ld2])||ld1==ld2)
{
continue;
}
else
{
voeg_samen(ld1,ld2);
ans_indices.push_back(i);
}
}
/*for(int j=0; j<m; j++)
{
int ld=find_leader(j);
cerr << j << " has loop: " << has_loop[ld] << endl;
}
cerr << endl;*/
}
long long pow_two=1;
for(int i=0; i<ans_indices.size(); i++)
{
pow_two=(pow_two*2)%modd;
}
int a2=ans_indices.size();
printf("%I64d %d\n",pow_two,a2);
for(int i=0; i<ans_indices.size(); i++)
{
if(i != 0) printf(" ");
printf("%d",ans_indices[i]+1);
}
printf("\n");
return 0;
}
|
#include<bits/stdc++.h>
#define ll long long
#define FOR(i, s, e) for (int i = (s); i < (e); i++)
#define FOE(i, s, e) for (int i = (s); i <= (e); i++)
#define FOD(i, s, e) for (int i = (s); i >= (e); i--)
#define mp make_pair
using namespace std;
int n, m;
int p[500005], self[500005];
set<int> s;
int find(int x) { if (p[x] == x) return x; return p[x] = find(p[x]); }
int main () {
scanf("%d %d", &n, &m);
FOE(i, 1, m) p[i] = i, self[i] = 0;
FOR(i, 0, n) {
int k;
scanf("%d", &k);
if (k == 1) {
int x;
scanf("%d", &x);
x = find(x);
if (self[x] == 0) {
self[x] = 1;
s.emplace(i + 1);
}
} else {
int x, y;
scanf("%d%d", &x, &y);
x = find(x);
y = find(y);
if (x != y && (self[x] != 1 || self[y] != 1)) {
p[x] = y;
self[y] = max(self[x], self[y]);
s.emplace(i + 1);
}
}
}
long long res = 1;
for (int i = 0; i < (int)s.size(); i++)
res = (res * 2) % 1000000007ll;
printf("%lld %d\n", res, (int)s.size());
for (int i : s) printf("%d ", i);
puts("");
return 0;
}
|
#include <cstdio>
#include <iostream>
#define ll long long
using namespace std;
int n , m , cnt = 0;
const int N = 5e5 + 5;
const int mod = 1e9 + 7;
ll pow2[N];
int num[N] , fa[N];
int find(int x){
if(fa[x] == x)
return x;
return fa[x] = find(fa[x]);
}
int main(){
pow2[0] = 1;
cin >> n >> m;
for(int i = 1; i < N; i++)
pow2[i] = 1ll * 2 * pow2[i - 1] % mod;
for(int i = 1; i <= m + 1; i++)
fa[i] = i;
for(int i = 1; i <= n; i++){
int k;
int x , y;
scanf("%d" , &k);
if(k == 1){
scanf("%d" , &x);
y = m + 1;
}
else
scanf("%d%d" , &x , &y);
int fx , fy;
fx = find(x);
fy = find(y);
if(fx == fy)
continue;
fa[fx] = fy;
num[++cnt] = i;
}
ll ans = pow2[cnt] % mod;
cout << ans << " " << cnt << endl;
for(int i = 1; i <= cnt; i++)
printf("%d " , num[i]);
return 0;
}
|
#include <bits/stdc++.h>
#define all(a) a.begin(), a.end()
#define db(a) cout << fixed << #a << " = " << a << endl;
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
const ll MOD = 1e9 + 7;
const int MAXM = 5e5 + 5;
vector<int> parent(MAXM, -1);
vector<int> rank_(MAXM, -1);
vector<int> indices;
int get_parent(int p) {
if (parent[p] == p) {
return p;
}
parent[p] = get_parent(parent[p]);
return parent[p];
}
int main(){
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, m;
cin >> n >> m;
vector<ll> pow2(MAXM);
pow2[0] = 1;
for (int i = 1; i < MAXM; i++) {
pow2[i] = pow2[i - 1] * 2;
pow2[i] %= MOD;
}
vector<vector<int>> X(n, vector<int>());
for (int i = 0; i < n; i++) {
int k;
cin >> k;
if (k == 1) {
int x1;
cin >> x1;
X[i].push_back(x1);
if (parent[x1] == -1) {
parent[x1] = x1;
rank_[x1] = 1;
indices.push_back(i);
} else {
int p1 = get_parent(x1);
if (rank_[p1] == 1) continue;
parent[p1] = p1;
indices.push_back(i);
rank_[p1] = 1;
}
} else {
int x1, x2;
cin >> x1 >> x2;
X[i].push_back(x1);
X[i].push_back(x2);
if (parent[x1] == -1 && parent[x2] == -1) {
int p = x1;
parent[x1] = p;
parent[x2] = p;
indices.push_back(i);
rank_[p] = 2;
} else if (parent[x1] == -1) {
int p = get_parent(x2);
parent[x1] = p;
indices.push_back(i);
} else if (parent[x2] == -1) {
int p = get_parent(x1);
parent[x2] = p;
indices.push_back(i);
} else {
int p1 = get_parent(x1);
int p2 = get_parent(x2);
if (p1 == p2 || (rank_[p1] == 1 && rank_[p2] == 1)) continue;
indices.push_back(i);
parent[p2] = p1;
rank_[p1] = min(rank_[p1], rank_[p2]);
}
}
}
vector<set<int>> iP(m + 1, set<int>());
for (int i: indices) {
for (int x: X[i]) {
assert(parent[x] != -1);
iP[get_parent(x)].insert(x);
}
}
ll ans = 1;
for (int i = 0; i < m + 1; i++) {
if (iP[i].empty()) continue;
int sz = (int) iP[i].size();
assert(sz > 0);
if (rank_[i] == 2) {
ans *= pow2[sz - 1];
} else {
ans *= pow2[sz];
}
ans %= MOD;
}
cout << ans << " " << indices.size() << endl;
for (int i: indices) {
cout << i + 1 << " ";
}
cout << endl;
}
|
#include<bits/stdc++.h>
#define mod 1000000007
using namespace std;
int fa[500005];
int vis[500005];
int num[500005];
vector<int> tt;
long long ans=1;
int n,m;
int t;
struct nod{
int tp,a,b,id;
}arr[500005];
int cmp(nod a,nod b)
{
if (a.tp!=b.tp) return a.tp<b.tp;
return a.id<b.id;
}
int find(int x){return x==fa[x]?x:fa[x]=find(fa[x]);}
void work()
{
scanf("%d%d",&n,&m);
for (int i=1;i<=m;i++) {fa[i]=i,vis[i]=0; num[i]=0;}
for (int i=1;i<=n;i++)
{
scanf("%d",&arr[i].tp);
arr[i].id=i;
if (arr[i].tp==1)
scanf("%d",&arr[i].a);
else
scanf("%d%d",&arr[i].a,&arr[i].b);
}
// sort(arr+1,arr+n+1,cmp);
for (int i=1;i<=n;i++)
{
if (arr[i].tp==1)
{
if (num[find(arr[i].a)]==0)
{
num[find(arr[i].a)]=1;
ans=ans+ans;
if (ans>=mod) ans-=mod;
tt.push_back(arr[i].id);
}
}
else
{
if (find(arr[i].a)!=find(arr[i].b))
{
if (num[find(arr[i].a)]==0 || num[find(arr[i].b)]==0)
{
num[find(arr[i].a)]+=num[find(arr[i].b)];
fa[find(arr[i].b)]=find(arr[i].a);
ans=ans+ans;
if (ans>=mod) ans-=mod;
tt.push_back(arr[i].id);
}
else
{
num[find(arr[i].a)]+=num[find(arr[i].b)];
fa[find(arr[i].b)]=find(arr[i].a);
}
}
}
}
printf("%lld %d\n",ans,(int)(tt.size()));
// sort(tt.begin(),tt.end());
int len=tt.size();
for (int i=0;i<len;i++)
printf("%d ",tt[i]);
printf("\n");
}
int main()
{
work();
}
|
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,avx2,fma")
#pragma GCC optimize("unroll-loops")
// #include <atcoder/all>
// #include <bits/stdc++.h>
#include <complex>
#include <queue>
#include <set>
#include <unordered_set>
#include <list>
#include <chrono>
#include <random>
#include <iostream>
#include <algorithm>
#include <cmath>
#include <string>
#include <vector>
#include <map>
#include <unordered_map>
#include <stack>
#include <iomanip>
#include <fstream>
using namespace std;
// using namespace atcoder;
typedef long long ll;
typedef long double ld;
typedef pair<int,int> p32;
typedef pair<ll,ll> p64;
typedef pair<p64,p64> pp64;
typedef pair<double,double> pdd;
typedef vector<ll> v64;
typedef vector<int> v32;
typedef vector<vector<int> > vv32;
typedef vector<vector<ll> > vv64;
typedef vector<vector<p64> > vvp64;
typedef vector<p64> vp64;
typedef vector<p32> vp32;
ll MOD = 1e9+7;
double eps = 1e-12;
#define forn(i,e) for(ll i = 0; i < e; i++)
#define forsn(i,s,e) for(ll i = s; i < e; i++)
#define rforn(i,s) for(ll i = s; i >= 0; i--)
#define rforsn(i,s,e) for(ll i = s; i >= e; i--)
#define ln '\n'
#define dbg(x) cout<<#x<<" = "<<x<<ln
#define mp make_pair
#define pb push_back
#define fi first
#define se second
#define INF 2e18
#define fast_cin() ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL)
#define all(x) (x).begin(), (x).end()
#define sz(x) ((ll)(x).size())
#define zero ll(0)
#define set_bits(x) __builtin_popcountll(x)
// #define mint modint998244353
ll mpow(ll a, ll b){
if(a==0) return 0;
if(b==0) return 1;
ll t1 = mpow(a,b/2);
t1 *= t1;
t1 %= MOD;
if(b%2) t1 *= a;
t1 %= MOD;
return t1;
}
ll mpow(ll a, ll b, ll p){
if(a==0) return 0;
if(b==0) return 1;
ll t1 = mpow(a,b/2,p);
t1 *= t1;
t1 %= p;
if(b%2) t1 *= a;
t1 %= p;
return t1;
}
ll modinverse(ll a, ll m){
ll m0 = m;
ll y = 0, x = 1;
if (m == 1) return 0;
while (a > 1){
ll q = a / m;
ll t = m;
m = a % m, a = t;
t = y;
y = x - q * y;
x = t;
}
if (x < 0) x += m0;
return x;
}
mt19937_64 mt(chrono::steady_clock::now().time_since_epoch().count());
ll range(ll l, ll r){
return l + mt()%(r-l+1);
}
ll rev(ll v){
return mpow(v,MOD-2);
}
ll nc2(ll n){
return (n*(n-1))/2;
}
// UnionFind U(n) :- n is number of elements
class UnionFind {
v64 p, rank, sz;
public:
UnionFind(ll N) {
rank.assign(N, 0);
p.assign(N, 0);
sz.assign(N, 1);
forn(i,N) p[i] = i;
}
void inc(){
rank.pb(0);
p.pb(sz(p));
sz.pb(1);
}
ll findSet(ll i) { // returns the head of group containing element i
return (p[i] == i) ? i : (p[i] = findSet(p[i]));
}
bool isSameSet(ll i, ll j) { // checks whether i and j are in same group
return findSet(i) == findSet(j);
}
void unionSet(ll i, ll j) { // unify group containing i and j(if already in same set then do nothing)
if (!isSameSet(i, j)) {
ll x = findSet(i), y = findSet(j);
if (rank[x] > rank[y]) {
p[y] = x;
sz[x] += sz[y];
}
else {
p[x] = y;
if (rank[x] == rank[y]) rank[y]++;
sz[y] += sz[x];
}
}
}
ll sz1(ll i){ // returns the sz[i] (to check the size of group containing i use sz1(findSet(i)))
return sz[i];
}
};
void solve(){
ll n,m;
cin >> n >> m;
ll x[n][2];
UnionFind U(m+1);
v64 ans;
forn(i,n){
ll k;
cin >> k;
forn(j,k) cin >> x[i][j];
if(k==1){
if(!U.isSameSet(x[i][0],0)){
U.unionSet(0,x[i][0]);
ans.pb(i+1);
}
}
else{
if(!U.isSameSet(x[i][0],x[i][1])){
U.unionSet(x[i][0],x[i][1]);
ans.pb(i+1);
}
}
}
ll num = 1;
forn(i,sz(ans)){
num*=2;
num %= MOD;
}
cout << num << " " << sz(ans) << ln;
for(auto it : ans) cout << it << " ";
cout << ln;
}
int main()
{
fast_cin();
ll t=1;
// cin >> t;
forn(i,t) {
// cout << "Case #" << i+1 << ": ";
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef unsigned int ui;
typedef long long ll;
typedef unsigned long long ull;
const int N=1e6+2,p=1e9+7;
int f[N],st[N],ed[N];
int n,c,i,t,m,j,k,tp,x,y,ans,z,w,la,s;
inline int ksm(register int x,register int y)
{
register int r=1;
while (y)
{
if (y&1) r=(ll)r*x%p;
x=(ll)x*x%p;
y>>=1;
}
return r;
}
inline void read(register int &x)
{
register int c=getchar(),fh=1;
while ((c<48)||(c>57))
{
if (c=='-') {c=getchar();fh=-1;break;}
c=getchar();
}
x=c^48;c=getchar();
while ((c>=48)&&(c<=57))
{
x=x*10+(c^48);
c=getchar();
}
x*=fh;
}
int getf(int x) {return f[x]==x?x:f[x]=getf(f[x]);}
int main()
{
read(m);read(n);
for (i=1;i<=n;i++) f[i]=i;
for (i=1;i<=m;i++)
{
read(z);
if (z==1) {read(x);x=getf(x);if (!ed[x]) ed[x]=1,st[++tp]=i;continue;}
read(x);read(y);
x=getf(x);y=getf(y);
if (x==y||ed[x]&&ed[y]) continue;
st[++tp]=i;f[x]=y;ed[y]|=ed[x];
}
printf("%d %d\n",ksm(2,tp),tp);
for (i=1;i<=tp;i++) printf("%d%c",st[i],i==tp?10:32);
}
|
#include <iostream>
#include <set>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <map>
#include <vector>
#include <assert.h>
#include <queue>
typedef long long ll;
const int mod=1e9+7;
using namespace std;
int n,m,k,v,ans=1,x,y;
int a[500005],par[500005];
vector<int>res;
int find(int x){
return par[x]==x?x:par[x]=find(par[x]);
}
int main()
{
scanf("%d%d",&n,&m);
for(int i=1;i<=m;++i)
{
par[i]=i;
}
for(int i=1;i<=n;++i){
scanf("%d",&k);
a[1]=a[2]=m+1;
for(int j=1;j<=k;++j){
scanf("%d",&a[j]);
}
if((x=find(a[1]))!=(y=find(a[2]))){
par[y]=x;
ans=2ll*ans%mod;
res.push_back(i);
}
}
printf("%d %d\n",ans,(int)res.size());
for(auto &x:res){
printf("%d ",x);
}
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
#ifndef ONLINE_JUDGE
#define dbg(x...) do { cout << "\033[32;1m " << #x << " -> "; err(x); } while (0)
void err() { cout << "\033[39;0m" << endl; }
template<template<typename...> class T, typename t, typename... A>
void err(T<t> a, A... x) { for (auto v: a) cout << v << ' '; err(x...); }
template<typename T, typename... A>
void err(T a, A... x) { cout << a << ' '; err(x...); }
#else
#define dbg(...)
#endif
typedef long long ll;
typedef pair<int,int> pi;
typedef vector<int> vi;
template<class T> using vc=vector<T>;
template<class T> using vvc=vc<vc<T>>;
template<class T> void mkuni(vector<T>&v)
{
sort(v.begin(),v.end());
v.erase(unique(v.begin(),v.end()),v.end());
}
ll rand_int(ll l, ll r) //[l, r]
{
static mt19937_64 gen(chrono::steady_clock::now().time_since_epoch().count());
return uniform_int_distribution<ll>(l, r)(gen);
}
template<class T>
void print(T x,int suc=1)
{
cout<<x;
if(suc==1) cout<<'\n';
else cout<<' ';
}
template<class T>
void print(const vector<T>&v,int suc=1)
{
for(int i=0;i<v.size();i++)
print(v[i],i==(int)(v.size())-1?suc:2);
}
const int maxn = 5e5 + 5;
const int mod = 1e9 + 7;
int n, m, fa[maxn], x, y, t, vis[maxn];
pair<int, int> p[maxn];
vector<int> ans;
int fnd(int x)
{
if (fa[x] == x) return x;
return fa[x] = fnd(fa[x]);
}
void init()
{
for (int i = 0; i <= m; i++)
fa[i] = i;
}
ll qpow(ll a, ll b)
{
ll ans = 1;
while (b) {
if (b & 1) ans = ans * a % mod;
a = a * a % mod;
b >>= 1;
}
return ans;
}
int main()
{
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m;
init();
int cnt = 0;
for (int i = 0; i < n; i++) {
cin >> t;
if (t == 2) {
cin >> x >> y;
int fx = fnd(x), fy = fnd(y);
if (fx == fy) continue;
if (vis[fx] && vis[fy])
fa[fx] = fy;
else
fa[fx] = fy, vis[fy] |= vis[fx] , ans.push_back(i+1);
}
else {
cin >> x;
if (!vis[fnd(x)]) vis[fnd(x)] = 1, ans.push_back(i+1);
}
//cout << ans.size() << '\n';
}
cout << qpow(2, ans.size()) << ' ' << ans.size() <<'\n';
for (auto &x : ans)
cout << x << ' ';
cout << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
#define send {ios_base::sync_with_stdio(false);}
#define help {cin.tie(NULL);}
#define f first
#define s second
#define pb push_back
#define vi vector<long long>
#define vii vector<pair<long long,long long>>
#define dict unordered_map<long long, long long>
#define contains(d,x) (d.find(x)!=d.end())
typedef long long ll;
typedef long double lld;
typedef unsigned long long ull;
const lld pi = 3.14159265358979323846;
const ll mod = 1000000007;
// const ll mod = 998244353;
ll n, m, k, l, p, q, r, x, y, z, sz;
const ll template_array_size = 1e6 + 5;
ll a[template_array_size];
ll b[template_array_size];
ll c[template_array_size];
string s, t;
ll ans = 0;
ll ts[5000000];
ll power(int x, int y){
if(!y) return 1;
ll temp = power(x, y/2);
temp = (temp*temp)%mod;
if(y&1){
return (temp*x)%mod;
}
return temp;
}
int find(int i, ll rep[]) {
int t = i;
while(rep[i]!=i){
i = rep[i];
}
while(rep[t]!=t){
t = rep[t];
rep[t] = i;
}
return i;
}
int onion(int i, int j, ll rep[]){
i = find(i,rep);
j = find(j,rep);
rep[j] = i;
return i!=j;
}
void solve(int tc = 0) {
cin >> n >> m;
vector<vii> adj(m+1);
vi chosen;
for(int i=0; i<m+1; i++) a[i] = i;
for(int i=0; i<n; i++) {
cin >> x;
if (x==1) {
cin >> y;
x = 0;
} else {
cin >> x >> y;
}
if(onion(x,y,a)){
chosen.pb(i+1);
}
}
p = chosen.size();
ans = power(2,p);
cout << ans << " " << p << endl;
for(int i : chosen) cout << i <<" ";
cout << endl;
}
int main() {
send help
// int tc = 1;
// cin >> tc;
// for (int t = 0; t < tc; t++) solve(t);
solve();
}
|
/**
* Author : Ujjawal Pabreja [cuber_coder]
* Email : ujjawalpabreja99@gmail.com
*/
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define endl "\n"
void Solve() {
int n, m;
cin >> n >> m;
vector<int> vis(m);
vector<int> parent(m);
iota(parent.begin(), parent.end(), 0);
function<int(int)> Find = [&](int u) {
if (u != parent[u]) {
return parent[u] = Find(parent[u]);
}
return parent[u];
};
function<bool(int, int)> Unite = [&](int u, int v) {
u = Find(u);
v = Find(v);
if (u != v and vis[u] + vis[v] != 2) {
parent[v] = u;
vis[u] += vis[v];
return true;
}
return false;
};
int ans = 1, mod = 1e9 + 7;
vector<int> subset;
for (int i = 0; i < n; i++) {
int k;
cin >> k;
int u, v;
if (k == 1) {
cin >> u;
u--;
u = Find(u);
if (vis[u] == 0) {
vis[u] = 1;
subset.push_back(i + 1);
ans = (ans * 2) % mod;
}
} else {
cin >> u >> v;
u--, v--;
if (Unite(u, v)) {
subset.push_back(i + 1);
ans = (ans * 2) % mod;
}
}
}
cout << ans << " " << subset.size() << endl;
for (int i = 0; i < subset.size(); i++) {
cout << subset[i] << " \n"[i == subset.size() - 1];
}
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int testcases = 1;
// cin >> testcases;
for (int i = 1; i <= testcases; i++) {
Solve();
}
return 0;
}
|
#include <bits/stdc++.h>
#define rep(i, l, r) for (register int i = l; i <= r; i++)
#define per(i, r, l) for (register int i = r; i >= l; i--)
#define srep(i, l, r) for (register int i = l; i < r; i++)
#define sper(i, r, l) for (register int i = r; i > l; i--)
#define erep(i, x) for (register int i = h[x]; i; i = e[i].next)
#define erep2(i, x) for (register int& i = cur[x]; i; i = e[i].next)
#define pii pair<int, int>
#define pll pair<ll, ll>
#define pdd pair<double, double>
#define fi first
#define se second
#define ui unsigned int
#define ld long double
#define pb push_back
#define pc putchar
#define lowbit(x) (x & -x)
#define maxr 2000020
#define gc() ((p1 == p2 && (p2 = (p1 = buffer) + fread(buffer, 1, maxr, stdin), p1 == p2)) ? EOF : *p1++)
using namespace std;
namespace Fast_Read{
char buffer[maxr], *p1, *p2;
template<class T> void read_signed(T& x){
char ch = gc(); x = 0; bool f = 1;
while (!isdigit(ch) && ch != '-') ch = gc();
if (ch == '-') f = 0, ch = gc();
while ('0' <= ch && ch <= '9') x = (x << 1) + (x << 3) + ch - '0', ch = gc();
x = (f) ? x : -x;
}
template<class T, class... Args> void read_signed(T& x, Args&... args){
read_signed(x), read_signed(args...);
}
template<class T> void read_unsigned(T& x){
char ch = gc(); x = 0;
while (!isdigit(ch)) ch = gc();
while (isdigit(ch)) x = (x << 1) + (x << 3) + ch - '0', ch = gc();
}
template<class T, class... Args> void read_unsigned(T& x, Args&... args){
read_unsigned(x), read_unsigned(args...);
}
#define isletter(ch) ('a' <= ch && ch <= 'z')
int read_string(char* s){
char ch = gc(); int l = 0;
while (!isletter(ch)) ch = gc();
while (isletter(ch)) s[l++] = ch, ch = gc();
s[l] = '\0'; return l;
}
}using namespace Fast_Read;
int _num[20];
template <class T> void write(T x, char sep = '\n'){
if (!x) {putchar('0'), putchar(sep); return;}
if (x < 0) putchar('-'), x = -x;
int c = 0;
while (x) _num[++c] = x % 10, x /= 10;
while (c) putchar('0' + _num[c--]);
putchar(sep);
}
#define read read_unsigned
#define reads read_string
#define writes puts
#define maxn 600020
#define maxm
#define maxs
#define maxb
#define inf
#define eps
#define M 1000000007
#define ll long long int
int ufs[maxn], siz[maxn]; bool loop[maxn];
int find_root(int x){
return ufs[x] = (ufs[x] == x) ? x : find_root(ufs[x]);
}
bool merge(int x, int y){
x = find_root(x), y = find_root(y);
if (x == y || (loop[x] && loop[y])) return false;
ufs[x] = y;
loop[y] = loop[x] | loop[y];
siz[y] += siz[x];
return true;
}
int ans[maxn], cs = 0, n, m;
int main(){
int x, y, k;
read(n, m);
rep(i, 1, m) ufs[i] = i, siz[i] = 1, loop[i] = 0;
rep(i, 1, n) {
read(k);
if (k == 1) {
read(x);
x = find_root(x);
if (!loop[x]) loop[x] = 1, ans[++cs] = i;
}
else {
read(x, y);
if (merge(x, y)) ans[++cs] = i;
}
}
int res = 0;
rep(i, 1, m) {
if (ufs[i] == i) {
res = res + siz[i] + (loop[i] ? 0 : -1);
}
}
int out = 1;
rep(i, 1, res) out = out << 1, out %= M;
write(out, ' '), write(cs);
rep(i, 1, cs) write(ans[i], ' ');
return 0;
}
|
#include <math.h>
#include <stdio.h>
#include <algorithm>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
using namespace std;
typedef long long int lld;
typedef long double llf;
typedef pair<int, int> pii;
const lld M = 1e9 + 7;
const int MAXN = 500002;
int n, m;
vector<int> adj[MAXN];
int padre[MAXN];
int raiz(int nodo) {
if (padre[nodo] == -1) return nodo;
return padre[nodo] = raiz(padre[nodo]);
}
int pot2(int e) {
if (e == 0) return 1;
lld x = pot2(e / 2);
x *= x;
x %= M;
if (e & 1) x *= 2;
return x % M;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> m >> n;
fill(padre, padre + n + 1, -1);
vector<int> li;
for (int i = 0; i < m; ++i) {
int k;
cin >> k;
int a, b;
cin >> a;
if (k == 1) b = 0;
else cin >> b;
// Para ver si es l.i.
// aplicamos MST
int ra = raiz(a);
int rb = raiz(b);
if (ra == rb) continue; // el vector es l.d.
padre[ra] = rb;
li.push_back(i+1);
}
cout << pot2(li.size()) << " " << li.size() << "\n";
for (int x : li)
cout << x << " ";
cout << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template<class T, class U>
void ckmin(T &a, U b)
{
if (a > b) a = b;
}
template<class T, class U>
void ckmax(T &a, U b)
{
if (a < b) a = b;
}
#define MP make_pair
#define PB push_back
#define LB lower_bound
#define UB upper_bound
#define fi first
#define se second
#define SZ(x) ((int) (x).size())
#define ALL(x) (x).begin(), (x).end()
#define FOR(i, a, b) for (auto i = (a); i < (b); i++)
#define FORD(i, a, b) for (auto i = (a) - 1; i >= (b); i--)
typedef long long ll;
typedef long double ld;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef vector<pii> vpi;
typedef vector<pll> vpl;
const int MAXN = 5e5 + 13;
const int INF = 1e9 + 7;
int N, M;
int dsu[MAXN];
vector<pair<int, pii> > edges;
vi ans;
int prod = 1;
int get(int u)
{
return (u == dsu[u] ? u : dsu[u] = get(dsu[u]));
}
bool merge(int u, int v)
{
u = get(u);
v = get(v);
if (u == v) return false;
dsu[u] = v;
return true;
}
int32_t main()
{
cout << fixed << setprecision(12);
cerr << fixed << setprecision(4);
ios_base::sync_with_stdio(false); cin.tie(0);
cin >> M >> N;
iota(dsu, dsu + N + 1, 0);
FOR(i, 0, M)
{
int c;
cin >> c;
if (c == 1)
{
int x;
cin >> x;
edges.PB({i, {0, x}});
}
else
{
int x, y;
cin >> x >> y;
edges.PB({i, {x, y}});
}
}
for (auto e : edges)
{
int u = e.se.fi, v = e.se.se;
if (merge(u, v))
{
ans.PB(e.fi);
prod += prod; if (prod >= INF) prod -= INF;
}
}
cout << prod << ' ' << SZ(ans) << '\n';
FOR(i, 0, SZ(ans))
{
cout << ans[i] + 1 << " \n"[i == SZ(ans) - 1];
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define INF 10000000000000LL
typedef long long int ll;
typedef pair<ll,ll> ii;
typedef pair<ii,ll> iii;
typedef pair<ii,ii> ii2;
typedef vector<ll> vi;
typedef vector<ii> vii;
#define getbit(n,i) (((n)&(1LL<<(i)))!=0)
#define setbit0(n,i) ((n)&(~(1LL<<(i))))
#define setbit1(n,i) ((n)|(1LL<<(i)))
#define lastone(n) ((n)&(-(n)))
#define read freopen("debug//in.txt","r",stdin)
#define write freopen("debug//out.txt","w",stdout)
#define DBG(a) cerr<<#a<<" ->->->-> "<<a<<"\n"
#define fi first
#define se second
#define PI (acos(-1))
#define fastread ios::sync_with_stdio(false);cin.tie(NULL)
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
#define mod (1000000007)
#define asz 500005
template<class T,class V> ostream& operator<<(ostream &s,pair<T,V> a)
{
s<<a.fi<<' '<<a.se;
return s;
}
int p[asz];
int fnd(int i){
if(p[i] == i)return i;
return p[i] = fnd(p[i]);
}
int main()
{
fastread;
#ifdef FILE_IO2
read;
write;
#endif
int T=1;
// cin>>T;
for(int qq=1;qq<=T; qq++){
int n,m;
cin>>n>>m;
for(int i=1;i<=m+1;i++)p[i] = i;
vii v(n);
for(int i=0;i<n;i++){
int k;
cin>>k;
cin>>v[i].fi;
if(k == 2)cin>>v[i].se;
else v[i].se = m+1;
if(v[i].fi>v[i].se)swap(v[i].fi,v[i].se);
}
vi ans;
ll pw = 1;
for(int i=0; i<n; i++){
int u = fnd(v[i].fi);
int u2 = fnd(v[i].se);
if(u!=u2){
p[u2] = u;
ans.push_back(i+1);
pw = pw*2%mod;
}
}
cout<<pw<<' '<<ans.size()<<endl;
for(auto x:ans)cout<<x<<' ';
cout<<endl;
}
}
|
#include <bits/stdc++.h>
//#include <bits/extc++.h>
#define ll long long
#define ull unsigned ll
#define endl "\n"
#define pb push_back
#define ms(v,x) memset(v,x,sizeof(v))
#define ff first
#define ss second
#define td(v) v.begin(),v.end()
#define rep(i,a,n) for (int i=(a);i<(n);i++)
#define per(i,a,n) for (int i=(n-1);i>=a;i--)
#define trav(a, x) for(auto& a : x)
#define re(v) {for(auto &_re : v) cin >> _re;}
#define pr(v) {for(auto _pr : v) cout << _pr << " "; cout << endl;}
//#define sz(x) (int)(x).size()
#define all(x) x.begin(), x.end()
#define pii pair<int,int>
#define pll pair<ll,ll>
#define vi vector<int>
#define vl vector<ll>
#define eb emplace_back
using namespace std;
using vvi = vector<vi>;
using vvl = vector<vl>;
const ll M = 1e9 + 7;
//const ll M = 998244353;
//const ll M = 1e9 + 9;
//const ll M = 1e6;
#define tiii tuple<int,int,int>
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
ll binpow(ll a, ll b){
ll ret = 1;
while(b){
if(b & 1){
ret = ret * a % M;
}
a = a * a % M;
b >>= 1;
}
return ret;
}
void solve(){
int n, m;
cin >> n >> m;
vi basis(m + 1);
vi nxt(m + 1);
iota(td(nxt), 0);
function<int (int)> f = [&](int i){
if(nxt[i] == i or nxt[i] == -1) return nxt[i];
return nxt[i] = f(nxt[i]);
};
vector<vector<int>> vecs(n);
vector<int> s;
for(int i=0;i<n;i++){
int k; cin >> k;
vecs[i].resize(k);
re(vecs[i]);
sort(td(vecs[i]));
// check if is represented
int a = f(vecs[i][0]);
int b = -1;
if(k > 1) b = f(vecs[i][1]);
if(a == b){
continue;
}
if(a == -1){
if(b == -1) continue;
basis[b] = 1;
s.eb(i);
nxt[b] = -1;
}
else{
basis[a] = i;
s.eb(i);
nxt[a] = b;
}
}
cout << binpow(2, s.size()) << " " << s.size() << endl;
for(int x : s) cout << x + 1 << " ";
cout << endl;
}
int32_t main(){
ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
//freopen(".in", "r", stdin);
//freopen(".out", "w", stdout);
int t = 1;
//cin >> t;
while(t--){
solve();
}
}
|
#include<iostream>
#include<cstdlib>
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<random>
#include<ctime>
#include<vector>
#include<cmath>
#include<unordered_map>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
const int N=1e6+5,N2=20;
const ll INF=1e18+5;
inline ll read()
{
ll sum=0,fh=1;
char c=getchar();
while(c<'0'||c>'9')
{
if(c=='-')fh=-1;
c=getchar();
}
while(c>='0'&&c<='9')
{
sum=sum*10+c-'0';
c=getchar();
}
return sum*fh;
}
inline int read2(int *a)
{
int x=0;
char c=getchar();
while(c<'a'||c>'z')c=getchar();
while(c>='a'&&c<='z')
{
a[++x]=c;
c=getchar();
}
return x;
}
inline void write(ll x)
{
if(x<0)putchar('-'),x=-x;
if(x>9)write(x/10);
putchar(x%10+'0');
}
inline int gcd(int x,int y)
{
return y==0?x:gcd(y,x%y);
}
inline int ab(int x)
{
return x<0?-x:x;
}
#define pi pair<int,int>
int fa[N];
inline int fifa(int x)
{
return x==fa[x]?x:fa[x]=fifa(fa[x]);
}
int a[N]={0};
int ans[N],js=0;
pi c[N];
int main()
{
//freopen("qwq.txt","r",stdin);
int n=read(),m=read();
for(int i=1;i<=m+1;++i)fa[i]=i;
for(int i=1;i<=n;++i)
{
int k=read();
int x=read(),y=(k==2?read():m+1);
if(x>y)swap(x,y);
if(!a[x])
{
a[x]=i;
ans[++js]=i;
fa[x]=y;
}
else
{
int x2=fifa(c[a[x]].first);
if(x2!=y)
{
x=x2;
if(x>y)swap(x,y);
if(!a[x])
{
a[x]=i;
ans[++js]=i;
fa[x]=y;
}
else
{
int x2=fifa(c[a[x]].first);
if(x2!=y)
{
x=x2;
if(x>y)swap(x,y);
if(x!=m+1&&!a[x])
{
a[x]=i;
ans[++js]=i;
fa[x]=y;
}
}
}
}
}
c[i]=pi(x,y);
}
int sum=1,p=1e9+7;
for(int i=1;i<=js;++i)
{
sum=(sum*2)%p;
}
cout<<sum<<" "<<js<<endl;
for(int i=1;i<=js;++i)
{
write(ans[i]),putchar(' ');
}
}
|
// codeforce
// wangqc
#include<iostream>
#include<vector>
using namespace std;
const int M = 1e9+7;
vector<int> p, rk, ans;
int find(int x)
{
return x == p[x] ? x : p[x]=find(p[x]);
}
int connect(int x, int y)
{
int px = find(x), py = find(y);
if(px == py) return false;
if(rk[px] < rk[py]) swap(px, py);
if(rk[px] == rk[py]) rk[px]++;
p[py] = px;
return true;
}
int main()
{
int n, m;
cin >> n >> m;
p.resize(m+2), rk.resize(m+2), ans.clear();
for(int i = 0; i <= m; i++)
p[i] = i, rk[i] = 0;
int k, x, y;
for(int i = 1; i <= n; i++)
{
cin >> k >> x;
if(k == 1) y = m+1;
else cin >> y;
if(connect(x, y)) ans.push_back(i);
}
n = ans.size(), m = 1;
for(int _ = 0; _ < n; _++) m = (m<<1) % M;
cout << m << " " << n << endl;
for(int i : ans) cout << i << " ";
cout << endl;
return 0;
}
|
#include <string>
#include <vector>
#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<stack>
#include<queue>
#include<cmath>
#include<algorithm>
#include<functional>
#include<list>
#include<deque>
#include<bitset>
#include<set>
#include<map>
#include<unordered_map>
#include<unordered_set>
#include<cstring>
#include<sstream>
#include<complex>
#include<iomanip>
#include<numeric>
#include<cassert>
#include<random>
#define X first
#define Y second
#define pb push_back
#define rep(X,Y) for (int (X) = 0;(X) < (int)(Y);++(X))
#define reps(X,S,Y) for (int (X) = (int)(S);(X) < (int)(Y);++(X))
#define rrep(X,Y) for (int (X) = (int)(Y)-1;(X) >=0;--(X))
#define rreps(X,S,Y) for (int (X) = (int)(Y)-1;(X) >= (int)(S);--(X))
#define repe(X,Y) for ((X) = 0;(X) < (Y);++(X))
#define peat(X,Y) for (;(X) < (Y);++(X))
#define all(X) (X).begin(),(X).end()
#define rall(X) (X).rbegin(),(X).rend()
#define eb emplace_back
#define UNIQUE(X) (X).erase(unique(all(X)),(X).end())
#define Endl endl
#define NL <<"\n"
#define cauto const auto
using namespace std;
using ll=long long;
using pii=pair<int,int>;
using pll=pair<ll,ll>;
template<class T> using vv=vector<vector<T>>;
template<class T> inline bool MX(T &l,const T &r){return l<r?l=r,1:0;}
template<class T> inline bool MN(T &l,const T &r){return l>r?l=r,1:0;}
//#undef NUIP
#ifdef NUIP
#include "benri.h"
#else
#define out(args...)
#endif
void ouT(ll x,int d=3){auto re=to_string(x);if((int)re.size()>d) re=x>0?"oo":"-oo";cout<<string(d-re.size(),' ')<<re<<",";}
#ifdef __cpp_init_captures
template<typename T>vector<T> table(int n, T v){ return vector<T>(n, v);}
template <class... Args> auto table(int n, Args... args){auto val = table(args...); return vector<decltype(val)>(n, move(val));}
#endif
template<class A,class B> pair<A,B> operator+(const pair<A,B> &p,const pair<A,B> &q){ return {p.X+q.X,p.Y+q.Y};}
template<class A,class B,class C,class D> pair<A,B>& operator+=(pair<A,B> &p,const pair<C,D> &q){ p.X+=q.X; p.Y+=q.Y; return p;}
template<class A,class B> pair<A,B> operator-(const pair<A,B> &p,const pair<A,B> &q){ return {p.X-q.X,p.Y-q.Y};}
template<class A,class B,class C,class D> pair<A,B>& operator-=(pair<A,B> &p,const pair<C,D> &q){ p.X-=q.X; p.Y-=q.Y; return p;}
template<class A,class B> istream& operator>>(istream &is, pair<A,B> &p){ is>>p.X>>p.Y; return is;}
template<class T=ll> T read(){ T re; cin>>re; return move(re);}
template<class T=ll> T read(const T &dec){ T re; cin>>re; return re-dec;}
template<class T=ll> vector<T> readV(const int sz){ vector<T> re(sz); for(auto &x:re) x=read<T>(); return move(re);}
template<class T=ll> vector<T> readV(const int sz, const T &dec){ vector<T> re(sz); for(auto &x:re) x=read<T>(dec); return move(re);}
vv<int> readG(const int &n,const int &m){ vv<int> g(n); rep(_,m){ cauto a=read<int>(1),b=read<int>(1); g[a].pb(b); g[b].pb(a);} return move(g);}
vv<int> readG(const int &n){ return readG(n,n-1);}
#define TT cauto TTT=read();rep(_,TTT)
const ll MOD=1e9+7; //998244353;
ll modpow_(ll r,ll n,ll m=MOD){
ll re=1,d=r%m;
if(n<0)(n%=m-1)+=m-1;
for(;n;n/=2){
if(n&1)(re*=d)%=m;
(d*=d)%=m;
}
return re;
}
template <int mod=MOD> struct ModInt{
int v;
ModInt(int v=0):v(v){}
ModInt operator+(const ModInt &n)const{return v+n.v<mod ? v+n.v : v+n.v-mod;}
ModInt operator-(const ModInt &n)const{return v-n.v<0 ? v-n.v+mod : v-n.v;}
ModInt operator*(const ModInt &n)const{return ll(v)*n.v%mod;}
ModInt operator/(const ModInt &n)const{return ll(v)*modpow_(n.v%mod,-1,mod)%mod;}
ModInt operator+(const ll &n)const{return v+n<mod ? v+n : v+n-mod;}
ModInt operator-(const ll &n)const{return v-n<0 ? v-n+mod : v-n;}
ModInt operator*(const ll &n)const{return ll(v)*(n%mod)%mod;}
ModInt operator/(const ll &n)const{return ll(v)*modpow_(n%mod,-1,mod)%mod;}
ModInt& operator+=(const ModInt &n){v+=n.v; if(v>=mod) v-=mod; return *this;}
ModInt& operator-=(const ModInt &n){v-=n.v; if(v<0) v+=mod; return *this;}
ModInt& operator*=(const ModInt &n){v=ll(v)*n.v%mod; return *this;}
ModInt& operator/=(const ModInt &n){v=ll(v)*modpow_(n.v,-1,mod)%mod; return *this;}
ModInt& operator+=(const ll &n){v+=n; if(v>=mod) v-=mod; return *this;}
ModInt& operator-=(const ll &n){v-=n; if(v<0) v+=mod; return *this;}
ModInt& operator*=(const ll &n){v=ll(v)*n%mod; return *this;}
ModInt& operator/=(const ll &n){v=ll(v)*modpow_(n,-1,mod)%mod; return *this;}
bool operator==(const ModInt &n)const{return v==n.v;};
bool operator!=(const ModInt &n)const{return v!=n.v;};
ModInt& operator++(){ return operator+=(1); }
ModInt& operator--(){ return operator-=(1); }
ModInt operator++(int i){ ModInt tmp(*this); operator++(); return tmp; }
ModInt operator--(int i){ ModInt tmp(*this); operator--(); return tmp; }
};
#ifdef NUIP
class MINT_FRAC____{
public:
unordered_map<int,pii> dict;
MINT_FRAC____(int n){
rep(p,n+1)reps(q,1,n+1)if(__gcd(p,q)==1){
dict[1ll*p*modpow_(q,-1)%MOD]=pii(p,q);
dict[MOD-1ll*p*modpow_(q,-1)%MOD]=pii(-p,q);
}
}
} Il1Il1Il1(1000);
template<int mod> ostream& operator<<(ostream &os,const ModInt<mod> &n){if(Il1Il1Il1.dict.count(n.v)) os<<n.v<<"("<<Il1Il1Il1.dict[n.v].X<<"/"<<Il1Il1Il1.dict[n.v].Y<<")";else os<<n.v;return os;};
#else
template<int mod> ostream& operator<<(ostream &os,const ModInt<mod> &n){return os<<n.v;};
#endif
template<int mod> ModInt<mod> operator+(const ll &n,const ModInt<mod> &m){return m.v+n<mod ? m.v+n : m.v+n-mod;}
template<int mod> ModInt<mod> operator-(const ll &n,const ModInt<mod> &m){return n-m.v<0 ? n-m.v+mod : n-m.v;}
template<int mod> ModInt<mod> operator*(const ll &n,const ModInt<mod> &m){return ll(m.v)*(n%mod)%mod;}
template<int mod> ModInt<mod> operator/(const ll &n,const ModInt<mod> &m){return ModInt<mod>(n%mod)/m;}
typedef ModInt<MOD> mint;
template <int mod> ModInt<mod> modpow(ModInt<mod> r,ll n){ ModInt<mod> re(1); if(n<0)(n%=mod-1)+=mod-1; for(;n;n/=2){if(n&1) re*=r; r*=r;} return re;}
vector<mint> fact,finv,inv;
mint comb(ll n,ll r){ if(n<r||r<0)return 0; return fact[n]*finv[n-r]*finv[r];}
class Doralion{
void Modinvs(vector<mint> &re,int n){ re.resize(n+1); re[1]=1; for(int i=2;i<=n;++i)re[i]=re[MOD%i]*(MOD-MOD/i);}
void Facts(vector<mint> &re,int n){ re.resize(n+1); re[0]=1; rep(i,n)re[i+1]=re[i]*(i+1);}
void Factinvs(vector<mint> &re,const vector<mint> &inv,int n){ re.resize(n+1); re[0]=1; rep(i,n)re[i+1]=re[i]*inv[i+1];}
public:
Doralion(int n){ Modinvs(inv,n); Facts(fact,n); Factinvs(finv,inv,n);}
} doralion(1123456);
using pmm=pair<mint,mint>;
mint modpow(ll r,ll n){ return modpow_(r,n);}
struct UF{
vector<int> data;
UF(int size):data(size,-1){}
bool unite(int x,int y){
x=root(x); y=root(y);
if(x!=y){
if(-data[y]>-data[x]) swap(x,y);
data[x]+=data[y]; data[y]=x;
}
return x!=y;
}
bool findSet(int x,int y){return root(x)==root(y);}
int root(int x){return data[x]<0?x:data[x]=root(data[x]);}
int size(int x) {return -data[root(x)];}
bool operator()(int x,int y){ return findSet(x,y);}
int operator[](int x){ return root(x);}
bool unti(int x,int y){ return unite(x,y);}
};
int main(){
ios_base::sync_with_stdio(false); cin.tie(0);
cout<<fixed<<setprecision(0);
cauto n=read();
cauto m=read();
vector<int> re;
UF uf(m+m);
rep(i,n){
cauto t=read();
out(i,t,1);
if(t==1){
cauto v=read(1);
out(v,1);
if(uf.unite(v,v+m)) re.eb(i);
}else{
cauto v=read(1);
cauto w=read(1);
out(i,t,v,w,1);
if(uf.unite(v,w)&uf.unite(v+m,w+m)) re.eb(i);
}
out(i,1);
}
out(re,1);
cout<<modpow(2,(int)re.size())<<" "<<re.size() NL;
for(cauto &v:re) cout<<v+1<<" ";
cout NL;
return 0;
}
|
#include <bits/stdc++.h>
#define endl '\n'
#define all(a) (a).begin(), (a).end()
#define len(a) (int) (a).size()
#define forn(i, n) for (int (i) = 0; (i) < (n); ++(i))
#define int long long
using namespace std;
void solve();
mt19937 rnd(2007);
signed main(){
#ifdef LOCAL
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#else
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
swap(rng, rnd);
#endif
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
solve();
}
struct dsu{
vector<int> p;
dsu(int n){
p.resize(n);
forn (i, n) p[i] = i;
}
int get(int v){
if (p[v] == v)
return v;
return p[v] = get(p[v]);
}
bool unite(int v, int u){
v = get(v), u = get(u);
p[v] = u;
return v != u;
}
};
const int mod = (int) 1e9 + 7;
void solve() {
int m; cin >> m;
int n; cin >> n;
dsu ds(n + 1);
vector<int> ans;
forn (qwe, m){
int k; cin >> k;
if (k == 1){
int v; cin >> v;
if (ds.get(v) != ds.get(0)) {
ds.unite(v, 0);
ans.push_back(qwe + 1);
}
}
else {
int v, u; cin >> v >> u;
if (ds.unite(v, u)){
ans.push_back(qwe + 1);
}
}
}
int res = 1;
forn (qwe, len(ans)){
res *= 2;
res %= mod;
}
cout << res << ' ' << len(ans) << endl;
for (auto i : ans){
cout << i << ' ';
}
cout << endl;
}
|
/*
构造一个正交化的线性基
实现完全正交 is impossible;
退而求之局部正交,即crucial musk不能出现在其他向量中
竟然要用并查集我日你先人(
*/
#include<bits/stdc++.h>
#define ll long long
using namespace std;
#define pb push_back
const int ha = 1e9+7;
inline int add(int x,int y){ x+=y; return x>=ha?x-ha:x;}
inline void ADD(int &x,int y){ x+=y; if(x>=ha) x-=ha;}
inline int ksm(int x,int y){
int an=1;
for(;y;y>>=1,x=x*(ll)x%ha) if(y&1) an=an*(ll)x%ha;
return an;
}
class liner_base{
public:
int n,*e,*hd,*ne,*tl;
char *ex;
liner_base(int N) : n(N){
e = new int [N+5];
hd = new int [N+5];
ne = new int [N+5];
tl = new int [N+5];
ex = new char [N+5];
memset(hd,0,sizeof(int)*(N+3));
memset(ne,0,sizeof(int)*(N+3));
memset(tl,0,sizeof(int)*(N+3));
memset(ex,0,sizeof(char)*(N+3));
for(int i=0;i<=N;i++) e[i] = i;
}
~liner_base(){
/*
delete e;
delete hd;
delete ne;
delete tl;
delete ex;
*/
}
int gete(int x){ return e[x] == x ? x : (e[x] = gete(e[x]));}
inline void add_to_list(int Element,int List){
ne[Element] = hd[List];
e[Element] = List;
hd[List] = Element;
if(!tl[List]) tl[List] = Element;
}
void delete_list(int List){
for(int now = hd[List],NE;now;now = NE)
NE = ne[now] , e[now] = now , ne[now] = 0;
hd[List] = tl[List] = 0;
}
inline void alter_list(int List1,int List2){
if(!hd[List1]) return;
if(!hd[List2]) hd[List2] = hd[List1],tl[List2] = tl[List1];
else ne[tl[List2]] = hd[List1],tl[List2] = tl[List1];
hd[List1] = tl[List1] = 0;
}
inline void add(int x){ /*printf("add %d\n",x),*/ex[x] = 1,e[x] = x,delete_list(x);}
inline void add(int x,int y){ /*printf("add %d %d\n",x,y),*/ex[x] = 1,alter_list(x,y),add_to_list(x,y);}
inline bool insert(int x){
if(ex[x] && gete(x) == x) return 0;
if(ex[x]) add(gete(x));
else add(x);
return 1;
}
inline bool insert(int x,int y){
if(x == y) return 0;
if(ex[x] && (gete(x) == x)) return insert(y);
else if(ex[x]) return insert(min(gete(x),y),max(gete(x),y));
else if(ex[y] && gete(y) == y) return insert(x);
else if(ex[y]) return insert(x,gete(y));
else add(x,y);
return 1;
}
inline void consistent_check(){
int *color = new int [n+5];
memset(color,0,sizeof(int)*(n+3));
for(int i=1;i<=n;i++)
for(int j=hd[i];j;j=ne[j]) color[j] = i;
for(int i=1;i<=n;i++) if(ex[i] && !color[i]) color[i] = i;
for(int i=1;i<=n;i++) if(ex[i] && color[i] != gete(i))
printf("There is an unconsistent with node %d\ncolor is %d, but father is %d\n",i,color[i],gete(i));
}
inline void check(){
for(int i=1;i<=n;i++) if(ex[i]) printf("%d : %d\n",i,gete(i));
}
};
int main(){
// freopen("data.in","r",stdin);
// freopen("data.out","w",stdout);
int n,m; scanf("%d%d",&n,&m);
liner_base a(m);
queue<int> q;
for(int opt,X,Y,i=1;i<=n;i++){
scanf("%d",&opt);
if(opt==1){
scanf("%d",&X);
if(a.insert(X)) q.push(i);
}
else{
scanf("%d%d",&X,&Y);
if(a.insert(min(X,Y),max(X,Y))) q.push(i);
}
}
// a.consistent_check();
printf("%d %d\n",ksm(2,q.size()),(int)q.size());
while(!q.empty()) printf("%d ",q.front()),q.pop();
// a.check();
return 0;
}
|
#include "bits/stdc++.h"
using namespace std;
#define rep(i, a, b) for(int i=a; i<=b; i++)
#define trav(a, x) for(auto& a : x)
#define all(x) begin(x), end(x)
#define sz(x) (int) x.size()
#define pb push_back
#define f first
#define s second
#define nl "\n"
typedef long long ll;
typedef pair<int, int> pii;
typedef vector<int> vi;
const int MOD = 1e9+7;
template<class T> using pqg = priority_queue<T,vector<T>,greater<T>>;
int n, m;
vector<pii> e;
bool self[500001];
int par[500001];
int sz[500001];
bool del[500001];
bool vis[500001];
bool has[500001];
int find(int x){
if(x==par[x]) return x;
return par[x]=find(par[x]);
}
void join(int x, int y){
int a=find(x);
int b=find(y);
if(a!=b){
sz[a]+=sz[b];
par[b]=a;
has[a] |= has[b];
}
}
ll bpow(ll a, ll b){
if(b==0) return 1;
ll y=bpow(a, b/2);
y=(y*y)%MOD;
if(b&1) y=(y*a)%MOD;
return y;
}
int main(){
ios::sync_with_stdio(false);
cin.tie(0);
// freopen("input.txt", "r", stdin);
// freopen("output.txt", "w", stdout);
cin >> n >> m;
rep(i, 1, m){
par[i]=i;
sz[i]=1;
}
rep(i, 1, n){
int x=-1; int y=-1;
int a;
cin >> a;
cin >> x;
if(a>1) cin >> y;
if(y==-1){
e.pb({x, x});
}
else e.pb({x, y});
}
ll ans=1;
rep(i, 0, sz(e)-1) {
pii p=e[i];
if(p.f!=p.s){
if(find(p.f)==find(p.s) || (has[find(p.f)] && has[find(p.s)])) del[i]=true;
}
else{
if(has[find(p.f)]) del[i]=true;
has[(find(p.f))]=true;
}
join(p.f, p.s);
}
rep(i, 1, m){
int p=find(i);
if(vis[p]) continue;
ans=(ans*bpow(2, sz[p]-1))%MOD;
if(has[p]) ans=(ans*2)%MOD;
vis[p]=true;
}
cout << ans << " ";
vi vec;
rep(i, 0, n-1){
if(!del[i]) vec.pb(i);
}
cout << sz(vec) << nl;
trav(k, vec) cout << k+1 << " ";
}
|
#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
const int N = 500000;
const long long modd = 1000000007;
int n, m;
int kk;
int aa[N + 5];
long long anss[N + 5], co = 0;
int ff[N + 5];
struct ab
{
int u;
int v;
} ee[N + 5];
long long qpow(long long a, long long b)
{
long long c = 1;
while (b)
{
if (b & 1)
{
c = c * a % modd;
}
a = a * a % modd;
b >>= 1;
}
return c;
}
int find(int x)
{
if (ff[x] != x)
{
return ff[x] = find(ff[x]);
}
return x;
}
int main()
{
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++i)
{
scanf("%d", &kk);
ee[i].v = m + 1;
if (kk == 1)
{
scanf("%d", &ee[i].u);
}
else
{
scanf("%d%d", &ee[i].u, &ee[i].v);
}
}
for (int i = 1; i <= m + 1; ++i)
{
ff[i] = i;
}
for (int i = 1; i <= n; ++i)
{
int a = find(ee[i].u);
int b = find(ee[i].v);;
if (a != b)
{
ff[a] = b;
anss[++co] = i;;
}
}
printf("%lld %lld\n", qpow(2, co), co);
for (int i = 1; i <= co; ++i)
{
printf("%lld ", anss[i]);;
}
return 0;;
}
|
#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define pll pair<ll,ll>
ll inf = 4e18, mod = 1e9 + 7;
inline ll power(ll x, ll n, ll m = LLONG_MAX)
{
ll res = 1; x = (x % m + m) % m;
while (n)
{ if (n & 1) res = (res * x) % m;
x = (x * x) % m; n >>= 1;
}
return res;
}
int dsu[500005], siz[500005];
vector<int> res;
void init() {
for (int i = 0; i < 500005; i++) dsu[i] = i, siz[i] = 1;
}
int find_parent(int x) {
return dsu[x] == x ? x : find_parent(dsu[x]);
}
void merge(int x, int y, int z) {
x = find_parent(x);
y = find_parent(y);
if (x == y) return;
if (siz[x] < siz[y]) swap(x, y);
siz[x] += siz[y];
dsu[y] = x;
res.push_back(z);
}
void solve() {
int n, m;
cin >> n >> m;
init();
set <pair<int, pair<int, int>>> s;
for (int i = 1; i <= n; i++) {
int k, x, y;
cin >> k;
if (k == 1) {
cin >> x;
s.insert({i, {0, x}});
}
else {
cin >> x >> y;
s.insert({i, {x, y}});
}
}
while (!s.empty()) {
auto it = s.begin();
pair<int, pair<int, int>> p = *it;
s.erase(it);
merge(p.second.first, p.second.second, p.first);
}
cout << power(2, res.size(), mod) << " " << res.size() << endl;
for (auto it : res)
cout << it << " ";
cout << endl;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int t = 1;
while (t--) solve();
}
|
#include <bits/stdc++.h>
#define MOD 1000000007
#define all(x) x.begin(), x.end()
using namespace std;
typedef long long ll;
typedef vector<ll> dlist;
typedef vector<dlist> matrix;
struct DS{
vector<bool> uni;
vector<int> p, c;
DS(int n): p(n, 0), c(n, 1), uni(n, false){
for(int i = 0; i < n; ++i)
p[i] = i;
}
int SetOf(int x){
return (p[x] == x)? x : p[x] = SetOf(p[x]);
}
bool Merge(int x, int y){
x = SetOf(x);
y = SetOf(y);
if((x == y) || (uni[x] && uni[y]))
return false;
if(c[x] < c[y])
swap(x, y);
p[y] = x;
c[x] += c[y];
uni[x] = (uni[x] | uni[y]);
return true;
}
};
void solve(){
int n, m;
cin >> n >> m;
matrix data(n);
DS ds(m + 1);
vector<int> sel;
for(int i = 0; i < data.size(); ++i){
auto &x = data[i];
int v; cin >> v;
for(int j = 0; j < v; ++j){
int k; cin >> k;
x.push_back(k);
}
if(v == 1){
v = ds.SetOf(x[0]);
if(ds.uni[v]) continue;
ds.uni[v] = true;
}
else if(!ds.Merge(x[0], x[1]))
continue;
sel.push_back(i);
}
int cant = 0;
for(int i = 1; i <= m; ++i){
int v = ds.SetOf(i);
cant += (ds.c[v] - !ds.uni[v]) * (v == i);
}
ll ans = 1;
for(int i = 1; i <= cant; ++i)
ans = (ans * 2) % MOD;
cout << ans << " " << cant << "\n";
for(auto &x:sel)
cout << x + 1 << " \n"[&x == &sel.back()];
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int t = 1;
while(t--) solve();
return 0;
}//RUL0
|
#include <bits/stdc++.h>
#define LL long long
#define rep(i, s, t) for (register int i = (s), i##end = (t); i <= i##end; ++i)
#define dwn(i, s, t) for (register int i = (s), i##end = (t); i >= i##end; --i)
using namespace std;
inline int read() {
int x = 0, f = 1;
char ch = getchar();
for (; !isdigit(ch); ch = getchar()) if (ch == '-') f = -f;
for (; isdigit(ch); ch = getchar()) x = 10 * x + ch - '0';
return x * f;
}
int a[500010], fa[500010], vis[500010], mod = 1e9 + 7;
inline int find(int x) { return x==fa[x]?x:fa[x]=find(fa[x]); }
int main() {
int n = read(), m = read(), T = 0;
rep(i, 1, m) fa[i] = i;
rep(i, 1, n) {
int opt = read();
if(opt == 2) {
int u = read(), v = read();
u = find(u), v = find(v);
if((vis[u] && vis[v]) || u == v) continue;
fa[u] = v; vis[v] |= vis[u];
a[i] = 1; ++T;
} else {
int u = read(); u = find(u);
if(!vis[u]) a[i] = 1, T++, vis[u] = 1;
}
}
int cur = T, pns = 1, bs = 2;
rep(i, 1, T) pns = 2LL * pns % mod;
cout << pns << " " << T << endl;
rep(i, 1, n) if(a[i]) cout << i << " ";
}
|
#include <stdio.h>
#include <vector>
using namespace std;
const int mod = 1e9 + 7;
int p[500001];
int find(int a) {
if (p[a] != a) p[a] = find(p[a]);
return p[a];
}
bool dsu(int a, int b) {
a = find(a); b = find(b);
if (a == b) return 0;
p[b] = a;
return 1;
}
int main() {
int i, n, m;
long long T = 1;
vector<int> S;
for (scanf("%d%d", &n,&m), i = 1; i <= m; ++i) p[i] = i;
for (i = 1; i <= n; ++i) {
int k, x1, x2;
scanf("%d%d",&k,&x1);
if (k > 1) scanf("%d",&x2);
else x2 = 0;
if (dsu(x1, x2)) {
T = (T + T) % mod;
S.push_back(i);
}
}
printf("%I64d %d\n",T,S.size());
for (auto x : S) printf("%d ",x);
return 0;
}
|
#include <bits/stdc++.h>
#define int long long
using namespace std;
int MOD=1e9+7;
int id[500005], sz[500005];
int find(int x){
while(x!=id[x]){
id[x]=id[id[x]];
x=id[x];
}
return x;
}
void unite(int i, int j){
int x=find(i), y=find(j);
if(sz[x]<sz[y]) swap(x, y);
sz[x]+=sz[y];
id[y]=x;
}
signed main(){
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, m;
cin>>n>>m;
for(int i=0;i<=m;i++){
id[i]=i;
sz[i]=1;
}
int ans=1;
vector<int>v;
for(int i=0;i<n;i++){
int k, x, y;
cin>>k>>x;
if(k==1) y=0;
else cin>>y;
if(find(x)!=find(y)){
unite(x, y);
ans=(ans*2)%MOD;
v.push_back(i+1);
}
}
cout<<ans<<" "<<v.size()<<"\n";
for(int i:v) cout<<i<<" ";
cout<<endl;
}
|
#include <bits/stdc++.h>
#define all(x) x.begin(), x.end()
#define rall(x) x.rbegin(), x.rend()
#define int long long
#define ll long long
#define pb push_back
#define ppb pop_back
#define pf push_front
#define ppf pop_front
#define ff first
#define ss second
#define ld long double
#define pii pair<int, int>
#define prev prev228
#define left left228
#define right right228
#define dist dist228
#define tm tm228
using namespace std;
mt19937 rnd(time(nullptr));
const long long INF = 1e18, P = 1e9 + 7, N = 5e5 + 10;
const long double EPS = 1e-9;
int pr[N], rk[N], used[N];
vector<int> ans, to_used[N];
vector<pair<int, int> > ed;
map<pair<int, int>, int> mp;
int get_root(int x) {
return (x == pr[x] ? x : pr[x] = get_root(pr[x]));
}
void mrg(int y1, int y2) {
if (rk[y1] > rk[y2]) {
swap(y1, y2);
}
pr[y1] = y2;
if (rk[y1] == rk[y2]) {
rk[y2]++;
}
}
bool add(int v, int u) {
v = get_root(v);
u = get_root(u);
if (v == u) {
return false;
}
mrg(v, u);
return true;
}
void do_used(int x) {
used[x] = 1;
vector<int> st = {x};
while (st.size() > 0) {
int v = st.back();
st.pop_back();
for (int u : to_used[v]) {
if (!used[u]) {
used[u] = 1;
st.push_back(u);
}
}
}
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
//cout << setprecision(15) << fixed;
//freopen("input.txt", "r", stdin);
//freopen("output.txt", "w", stdout);
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) {
int k;
cin >> k;
if (k == 1) {
int x;
cin >> x;
x--;
if (!used[x]) {
ans.push_back(i + 1);
do_used(x);
}
} else {
int v, u;
cin >> v >> u;
v--;
u--;
mp[{v, u}] = i;
if (!used[v] || !used[u]) {
ed.push_back({v, u});
if (!used[v] && !used[u]) {
to_used[v].push_back(u);
to_used[u].push_back(v);
} else if (!used[v]) {
do_used(v);
} else if (!used[u]) {
do_used(u);
}
}
}
}
for (int i = 0; i < m; i++) {
pr[i] = i;
rk[i] = 1;
}
for (pair<int, int> p : ed) {
int v = p.ff, u = p.ss;
if (add(v, u)) {
ans.push_back(mp[{v, u}] + 1);
}
}
sort(all(ans));
int pw = 1;
for (int i = 0; i < ans.size(); i++) {
pw *= 2;
pw %= P;
}
cout << pw << ' ' << ans.size() << "\n";
for (int elem : ans) {
cout << elem << ' ';
}
cout << "\n";
return 0;
}
|
#include<iostream>
#include<bits/stdc++.h>
using namespace std;
#define IOS ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
typedef int _loop_int;
#define REP(i,n) for(_loop_int i=0;i<(_loop_int)(n);++i)
#define FOR(i,a,b) for(_loop_int i=(_loop_int)(a);i<(_loop_int)(b);++i)
#define FORR(i,a,b) for(_loop_int i=(_loop_int)(b)-1;i>=(_loop_int)(a);--i)
#define DEB(x) cout << #x << " " << x << endl;
#define DEB_VEC(v) cout<<#v<<":";REP(i,v.size())cout<<" "<<v[i];cout<<endl
#define ALL(a) (a).begin(),(a).end()
#define CHMIN(a,b) a=min((a),(b))
#define CHMAX(a,b) a=max((a),(b))
typedef long long int LL;
typedef pair<int, int> PI;
typedef pair<LL, LL> PLL;
typedef vector<int> VI;
typedef vector<LL> VL;
void solve() {
int n, m;
cin >> n >> m;
int a[n];
REP(i, n)
cin >> a[i];
// cout << "question " << endl;
// REP(i, n)
// cout << a[i] << " ";
// cout << endl;
LL peak = LONG_MIN;
LL sum = 0;
map<LL, int> mp;
REP (i, n) {
sum += a[i];
if (mp.count(sum) == 0 && peak < sum)
mp[sum] = i+1;
CHMAX(peak, sum);
}
// for (auto x: mp)
// cout << x.first << ": " << x.second << ", ";
// cout << endl;
LL offset = sum;
unordered_map<int, LL> res;
REP(q, m) {
int x;
cin >> x;
if (res.count(x)) {
cout << res[x] << " ";
continue;
}
// cout << "x " << x << " : ";
if (peak < x && offset <= 0) {
// cout << -1 << " inf" <<endl;
cout << -1 << " ";
continue;
}
// DEB(offset);
// if (peak >= x) {
// auto it = mp.lower_bound(x);
// // DEB(it->second);
// sec += it->second;
// // cout << sec << endl;
// cout << sec << " ";
// continue;
// }
LL k = peak >= x ? 0: (x-peak + offset-1) / offset;
// cout << "x " << x << " k " << k << endl;
LL sec = peak >= x? -1: n*k - 1;
// LL acc = 0;
LL koff = k*offset;
// LL now;
// REP(i, n) {
// acc += a[i];
// now = koff + acc;
// sec++;
// if (now > x) {
// break;
// }
// if (now == x)
// break;
// }
LL search = x - koff;
// DEB(search);
auto it = mp.lower_bound(search);
// DEB(it->second);
sec += it->second;
cout << sec << " ";
res[x] = sec;
}
cout << endl;
}
int main() {
IOS
int t;
cin >> t;
while (t--) {
solve();
}
return 0;
}
/*
question
2 0
x 1 : -1
x 2 : 0
question
2 -1
x 2 : 0
x 1 : -2
1
3 3
1 2 4
3 1 2
3
3 3
1 2 4
3 1 2
2 2
2 0
1 2
2 2
2 -1
2 1
*/
|
//int max = 2 147 483 647 (2^31-1)
//ll max = 9 223 372 036 854 775 807 (2^63-1)
#include<bits/stdc++.h>
using namespace std;
#define forn(i,n) for(int i=0;i<n;i++)
#define mp make_pair
#define f first
#define s second
#define pb push_back
#define MOD 1000000007
typedef long long ll;
typedef long double ld;
typedef vector<int> vi;
typedef pair<int,int> pi;
//Fast input and output
void fast_io(){
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);}
//Printing pairs and vectors
template<typename A, typename B> ostream& operator<< (ostream &cout, pair<A,B> const &p) {return cout << "(" << p.f << ", " << p.s << ")";}
template<typename A> ostream& operator<< (ostream &cout, vector<A> const&v){
cout << "["; forn(i,(int)v.size()){ if (i) cout << ", "; cout << v[i];} return cout << "]";}
ll divi(ll a, ll b){
if(a>=0) return a/b;
return (a+1)/b-1;
}
//main code
int main(){
fast_io();
//cout << divi(-1,2) << endl;
int test; cin >> test;
forn(tc,test){
int n,m; cin >> n >> m;
vector<ll> a(n);
forn(i,n) cin >> a[i];
vector<ll> pref=a;
for(int i=1;i<n;i++) pref[i]+=pref[i-1];
vector<ll>pmax=pref;
for(int i=1;i<n;i++) pmax[i]=max(pmax[i],pmax[i-1]);
//cout << pref << " " << pmax << endl;
forn(i,m){
ll x, ans=0; cin >> x;
if(pref[n-1]>0){
ans=max(divi((x-pmax[n-1]-1),pref[n-1])+1,(ll)0)*n;
x-=max(divi((x-pmax[n-1]-1),pref[n-1])+1,(ll)0)*pref[n-1];
}
//cout << x << " " << ans << "\n";
int l=-1,r=n-1;
while(l+1<r){
int m=(l+r)/2;
if(pmax[m]<x) l=m;
else r=m;
}
//cout << r << " ";
if(pmax[r]>=x) cout << ans+r << " ";
else cout << "-1 ";
}
cout << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
#define ll long long
struct tr { ll r, s; int i; };
bool g(tr &a, tr &b) {
if(a.r == b.r && a.s == b.s) return a.i < b.i;
else if(a.r == b.r) return a.s > b.s;
else return a.r < b.r;
}
int main() {
ios::sync_with_stdio(false); cin.tie(nullptr); cout.tie(nullptr);
int t; cin>>t; while(t--) {
int n,m; cin>>n>>m;
vector<ll> a(n);
vector<pair<ll, pair<ll, int>>> p(n);
map<ll, int> mp;
for (int i = 0; i < n; ++i) {
cin>>a[i];
p[i].first = a[i] + (i > 0 ? p[i-1].first : 0);
if(i == 0 || p[i].first > p[i-1].second.first) {
p[i].second.first = p[i].first; p[i].second.second = i;
} else {
p[i].second.first = p[i-1].second.first; p[i].second.second = p[i-1].second.second;
}
mp[p[i].first] = i+1;
}
ll s = p[n-1].first;
for (int i = 0; i < m; ++i) {
ll x; cin>>x;
int l = -1, r = p[n-1].second.second+1; ll mx = p[n-1].second.first;
ll ans = (s <= 0 ? 0 : max(0LL, x-mx)/s + (max(0LL, x-mx) % s != 0));
while(l + 1 < r) {
int mid = (l + r) / 2;
if(ans * s + p[mid].second.first >= x) r = mid;
else l = mid;
}
if(r == p[n-1].second.second+1) cout << "-1 ";
else cout << ans*n + p[r].second.second << " ";
}
cout << "\n";
}
}
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn = 2e5 + 10;
const int INF = 0x3f3f3f3f;
int t;
int n,m;
ll a[maxn];
ll res[maxn];
ll x[maxn];
int main()
{
cin >> t;
while(t--)
{
cin >> n >> m;
ll sum = 0;
ll ma = 0;
for(int i = 1;i <= n; ++i)
{
cin >> a[i];
sum += a[i];
ma = max(ma,sum);
res[i] = ma;
}
for(int i = 1;i <= m; ++i)
{
ll x;
cin >> x;
if(x > ma && sum <= 0)
cout << -1 << " ";
else if(x <= ma)
{
int ans = lower_bound(res + 1, res + 1 + n,x) - res - 1;
cout << ans << " ";
}
else
{
ll ans = -1;
ll k = max((ll)0,(x - ma + sum - 1) / sum);
ans += n * k;
x -= k * sum;
ans += lower_bound(res + 1, res + 1 + n,x) - res;
cout << ans << " ";
}
}
cout << endl;
}
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define loop(a,b) for(ll i=a;i<b;i++)
#define pii pair<ll,ll>
#define F first
#define S second
#define mp make_pair
#define pb push_back
ll t,n,m,x,y,bal,MX;
vector<ll>a,pre,mx;
ll tell(ll x){
ll st=1,en=n,md,ans=0;
while(st<=en){
md=(st+en)/2;
if(mx[md]>=x) ans=md,en=md-1;
else st=md+1;
}
return ans;
}
int main() {
ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0);
cin>>t;
while(t--){
cin>>n>>m;
a=pre=mx=vector<ll>(n+2);
for(ll i=1;i<=n;++i){
cin>>a[i];
pre[i]=pre[i-1]+a[i];
mx[i]=max(mx[i-1],pre[i]);
}
bal=pre[n];
MX=mx[n];
for(ll i=1;i<=m;++i){
cin>>x;
if(x-MX<=0) cout<<tell(x)-1<<' ';
else if(bal<=0) cout<<-1<<' ';
else{
y=ceil(((x-MX)*1.0)/bal);
cout<<y*n+tell(x-y*bal)-1<<' ';
}
}
cout<<'\n';
}
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
#define endl ("\n")
#define mp make_pair
#define fi first
#define se second
#define pb push_back
#define ll long long
#define llu long long unsigned
#define fast ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
#define inpotp freopen("input.txt", "r", stdin); freopen("output.txt", "w", stdout);
#define fr(i,n) for(int i=0;i<n;i++)
#define fr1(i,n) for(int i=1;i<=n;i++)
#define rfr(i,n) for(int i=n-1;i>=0;i--)
#define all(x) x.begin(), x.end()
#define clr(x) memset(x, 0, sizeof(x))
#define sortall(x) sort(all(x))
#define tr(it, a) for(auto it = a.begin(); it != a.end(); it++)
#define PI 3.1415926535897932384626
#define prdb(x) cout << fixed << setprecision(10) << x
#define sc(a) scanf("%d",&a)
#define pf(a) printf("%d",a)
#define cs(a) cout<<a<<' '
#define cn(a) cout<<a<<'\n'
#define ub(a,v) upper_bound(a.begin(), a.end(), v)
#define lb(a,v) lower_bound(a.begin(), a.end(), v)
int main()
{
fast
int t=1;
cin>>t;
while(t--){
ll n,m,a;
cin>>n>>m;
ll arr[n+1];
fr1(i,n)cin>>arr[i];
arr[0]=0;
fr1(i,n)arr[i]+=arr[i-1];
ll mx[n+1];
mx[1]=arr[1];
for(int i=2;i<=n;i++)mx[i]=max(mx[i-1],arr[i]);
while(m--){
cin>>a;
if(a<=arr[1]){cout<<"0 "; continue;}
if(a>mx[n] && arr[n]<=0){cout<<"-1 "; continue;}
ll ans=-1;
if(a>mx[n] && arr[n]>0){
ans+=((a-mx[n])/arr[n])*n;
a=a-( ((a-mx[n])/arr[n])*arr[n] );
}
// cout<<ans<<" "<<a<<endl;
int l=0,r=n,mid;
if(a>0){
l=0; r=n;
while(r-l>1){
mid=(l+r)/2;
if(mx[mid]>=a)r=mid;
else l=mid;
}
ans+=r;
a=a-arr[r];
}
// cout<<ans<<" "<<a<<endl;
if(a>0){
l=0; r=n;
while(r-l>1){
mid=(l+r)/2;
if(mx[mid]>=a)r=mid;
else l=mid;
}
ans+=r;
a=a-arr[r];
}
cout<<ans<<" ";
}
cout<<endl;
}
return 0;
}
|
#include<stdio.h>
#define N 200007
#define ll long long
inline int read(){
int x=0,flag=1; char c=getchar();
while(c<'0'||c>'9'){if(c=='-') flag=0;c=getchar();}
while(c>='0'&&c<='9'){x=(x<<1)+(x<<3)+c-48;c=getchar();}
return flag? x:-x;
}
int T,n,m,a[N],top,pos[N];
ll sta[N];
int main(){
T=read();
while(T--){
n=read(),m=read();
ll now=0; top=0;
for(int i=1;i<=n;i++){
a[i]=read(),now+=a[i];
if(sta[top]<now) sta[++top]=now,pos[top]=i;
}
if(now<=0){
for(int i=1;i<=m;i++){
int x=read();
if(x>sta[top]) printf("-1 ");
else{
int l=1,r=top,ret=top;
while(l<=r){
int mid=(l+r)>>1;
if(sta[mid]>=x) r=mid-1,ret=mid;
else l=mid+1;
}
printf("%d ",pos[ret]-1);
}
}
putchar('\n');
}else{
for(int i=1;i<=m;i++){
int x=read();
ll tmp=x>sta[top]? (x-sta[top]-1)/now+1:0;
ll ans=1ll*n*tmp;
x-=tmp*now;
int l=1,r=top,ret=top;
while(l<=r){
int mid=(l+r)>>1;
if(sta[mid]>=x) r=mid-1,ret=mid;
else l=mid+1;
}
printf("%lld ",ans+pos[ret]-1);
}
putchar('\n');
}
}
}
|
// Author :: <Hitesh_Saini>
#include<bits/stdc++.h>
#define __speed() ios_base::sync_with_stdio(false), cin.tie(nullptr);
#define dbg(x) cout << "(" << __LINE__ << ": "<< #x << " = " << x << ")\n"
#define Yes(x) print((x) ? "Yes" : "No")
#define tt int t; for (cin >> t; t--; )
#define f0(i, n) for (i = 0; i < (int)(n); i++)
#define f1(i, n) for (i = 1; i <=(int)(n); i++)
#define all(x) x.begin(), x.end()
#define rall(x) x.rbegin(), x.rend()
#define sz(x) (int)(x.size())
#define EB emplace_back
#define PB push_back
#define endl "\n"
#define S second
#define F first
using namespace std;
using mii = map<int, int>;
using pii = pair<int, int>;
using ll = int64_t;
using vi = vector<int>;
using vvi = vector<vi>;
using vl = vector<ll>;
const int mod = 1e9+7, mxN = 5e6+5, INF = 0x3f3f3f3f;
const ll LINF = 0x3f3f3f3f3f3f3f3f;
template <typename... T> void print(T... args) { ((cout << args << " "), ...), cout << endl; }
template <typename T1, typename T2> istream& operator>>(istream& in, pair<T1, T2>& p) { in >> p.F >> p.S; return in; }
template <typename T1, typename T2> ostream& operator<<(ostream& ot, pair<T1, T2>& p) { ot << p.F << ' ' << p.S; return ot; }
template <typename T1, typename T2> bool cmax(T1& a, T2 b) { if (b > a) { a = b; return true;} return false; }
template <typename T1, typename T2> bool cmin(T1& a, T2 b) { if (b < a) { a = b; return true;} return false; }
template <typename T> istream& operator>>(istream& in, vector<T>& v) { for (T& x:v) in >> x; return in; }
template <typename T> ostream& operator<<(ostream& ot, vector<T>& v) { for (T& x:v) ot << x << ' '; return ot; }
void solve() {
ll n, m, i, required, sum = 0;
cin >> n >> m;
vl A(n), pref_max(n);
f0(i, n) {
cin >> A[i];
sum += A[i];
if (i==0)
pref_max[i] = sum;
else
pref_max[i] = max(sum, pref_max[i-1]);
}
while (m--) {
cin >> required;
if (required > pref_max.back() && sum <= 0) {
cout << "-1 ";
continue;
}
ll cycles = 0, c = 0;
if (required > pref_max.back()) { // cycles exist
cycles = (required - pref_max.back() + sum - 1) / sum;
c = cycles * n;
required -= cycles * sum;
}
c += lower_bound(all(pref_max), required) - pref_max.begin();
cout << c << ' ';
}
cout << endl;
}
signed main() {
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin); freopen("output.txt", "w", stdout);
#endif
__speed() tt solve();
}
|
#pragma GCC optimize("Ofast")
#pragma loop_opt(on)
#include<bits/stdc++.h>
#define Rushia_mywife ios::sync_with_stdio(0);cin.tie(0);
#define F first
#define S second
#define pb push_back
#define pob pop_back
#define pf push_front
#define pof pop_front
#define mp make_pair
#define mt make_tuple
#define FL cout.flush()
#define all(x) (x).begin(),(x).end()
#define mem(x,i) memset((x),(i),sizeof((x)))
using namespace std;
using ll = long long;
using pii = pair<int,int>;
using pll = pair<long long,long long>;
using ld = long double;
mt19937 mtrd(chrono::steady_clock::now().time_since_epoch().count());
const int mod = 1000000007;
const int mod2 = 998244353;
const ld PI = acos(-1);
#define Bint __int128
#define int long long
int qpow(int x,int powcnt,int tomod){
int res = 1;
for(;powcnt;powcnt>>=1,x=(x*x)%tomod)
if(1&powcnt)res = (res*x)%tomod;
return (res%tomod);
}
int inv(int x){ return qpow(x,mod-2,mod); }
// --------------------------------------**
int n,m;
void solve(){
cin >> n >> m;
int sum = 0;
vector<int>a(n);
for(int i=0;i<n;i++)
cin >> a[i];
vector<int>mx(n);
sum = mx[0] = a[0];
for(int i=1;i<n;i++)
sum += a[i],mx[i] = max(sum,mx[i-1]);
while(m--){
int x;
cin >> x;
if(mx[n-1]<x&&sum<=0){
cout << -1 << ' ';
continue;
}
int cir;
if(x<=mx[n-1])
cir = 0;
else
cir = (x-mx[n-1]+sum-1)/sum;
x -= cir*sum;
int ans = cir*n;
assert(x<=mx[n-1]);
int l = 0,r = n-1;
while(l<r){
int mid = (l+r)>>1;
if(mx[mid]>=x)
r = mid;
else
l = mid+1;
}
cout << ans+l << ' ';
}
cout << '\n';
}
signed main(){
Rushia_mywife
int t = 1;
cin >> t;
while(t--)
solve();
}
|
#include"bits/stdc++.h"
#define int long long
#define mod 1000000007
#define pf push_forward
#define pb push_back
#define mp make_pair
#define all(v) v.begin(),v.end()
#define f(i,in,n) for(i=in; i<n; ++i)
#define scant int t,t2055; cin>>t2055;for(t=1;t<=t2055;t++)
using namespace std;
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
scant {
int n, m, i, j;
cin >> n >> m;
int a[n];
for (i = 0; i < n; i++) {
cin >> a[i];
}
int sum = 0; map<int, int>m1;
for (i = 0; i < n; i++) {
sum += a[i];
if (m1.empty()) {
m1[sum] = i;
}
auto x = m1.end(); x--;
if (x->first < sum) {
m1[sum] = i;
}
}
while (m--) {
int x; cin >> x;
auto lb = m1.lower_bound(x);
if (lb != m1.end()) {
cout << lb->second << " "; continue;
}
if (sum <= 0) {
cout << -1 << " "; continue;
}
int mx; auto temp = m1.end(); temp--;
mx = temp->first;
x -= mx;
int turns = x / sum;
int left = x % sum;
left += mx;
if (left > mx) {
turns++;
left -= sum;
}
turns *= n;
turns--;
// cout << m1.lower_bound(left)-> << endl;
if (left > 0) {
lb = m1.lower_bound(left);
turns += lb->second;
// cout << m1[1];
turns++;
}
cout << turns << " ";
}
cout << endl;
}
}
|
#include <bits/stdc++.h>
#define fu(i,a,b) for (long long i=a; i<=b; i++)
#define fd(i,a,b) for (long long i=a; i>=b; i--)
using namespace std;
typedef long long ll;
const ll N=2e5+10;
ll n,q,a[N],s[N],ma[N],query[N];
void Solve()
{
cin>>n>>q;
fu(i,1,n)
{
cin>>a[i];
}
fu(i,1,q)
{
cin>>query[i];
}
fu(i,1,n)
{
s[i]=s[i-1]+a[i];
}
ma[0]=0;
fu(i,1,n)
{
ma[i]=max(ma[i-1],s[i]);
}
// fu(i,1,n)
// {
// cout<<s[i]<<" ";
// }
// cout<<"\n";
// fu(i,1,n)
// {
// cout<<ma[i]<<" ";
// }
// cout<<"\n";
if (s[n]<=0)
{
fu(i,1,q)
{
ll x=query[i];
ll l=1,r=n,res=0;
while (l<=r)
{
ll mid=(l+r)/2;
if (ma[mid]>=x)
{
res=mid;
r=mid-1;
}
else
{
l=mid+1;
}
}
cout<<res-1<<" ";
}
cout<<"\n";
return;
}
fu(i,1,q)
{
ll x=query[i];
ll L=0,R=(x/s[n])+10,res=0;
// cout<<"Tra loi "<<x<<":\n";
while (L<=R)
{
ll MID=(L+R)/2;
// cout<<MID<<":\n";
ll val=MID*s[n];
ll l,r,o=-1;
if (MID==0) {l=1;} else {l=0;}
r=n;
while (l<=r)
{
ll mid=(l+r)/2;
// cout<<l<<" "<<r<<" "<<mid<<"\n";
if (ma[mid]>=x-val)
{
o=mid;
r=mid-1;
}
else
{
l=mid+1;
}
}
// cout<<"\n";
// cout<<o<<"\n";
if (o==-1)
{
L=MID+1;
}
else
{
res=MID*n+o;
R=MID-1;
}
}
cout<<res-1<<" ";
// cout<<"\n";
}
// cout<<"---------------\n";
cout<<"\n";
}
int main()
{
cin.tie(NULL);
cout.tie(NULL);
ios_base::sync_with_stdio(false);
ll T;
cin>>T;
while (T--)
{
Solve();
}
}
|
#include<bits/stdc++.h>
using namespace std;
#define endl "\n"
#define lln long long int
#define ld long double
#define all(x) (x).begin(),(x).end()
#define IOS ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
const int MOD = 1e9 + 7;
int main(){
IOS;
int a1;
cin >> a1;
for(int TT=0;TT<a1;TT++){
int n, m;
cin >> n >> m;
vector<int> A(n);
vector<pair<lln,int>> pref;
for(int i=0;i<n;i++) cin >> A[i];
pref.push_back({A[0], 0});
lln ma = A[0], sum = A[0];
for(int i=1;i<n;i++){
sum += A[i];
if(sum > pref.back().first) pref.push_back({sum, i});
ma = max(ma, pref.back().first);
}
for(int i=0;i<m;i++){
int q;
cin >> q;
if(q <= A[0]){
cout << 0 << " ";
continue;
}
if(q > ma && sum <= 0){
cout << -1 << " ";
continue;
}
lln cal = 0, ans = 0;
if(ma < q){
ans = ((q - ma) / sum );
if((q - ma) % sum) ans ++;
q = q - ans * sum;
ans = ans * n;
}
int l = 0, r = pref.size() - 1;
while(q > 0 && l <= r){
int m = (l + r) / 2;
if(pref[m].first >= q){
cal = m;
r = m - 1;
}
else l = m + 1;
}
cout << ans + pref[cal].second << " ";
}
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define m_p make_pair
#define all(x) (x).begin(),(x).end()
#define sz(x) ((int)(x).size())
#define fi first
#define se second
typedef long long ll;
mt19937 rnd(chrono::steady_clock::now().time_since_epoch().count());
mt19937 rnf(2106);
const int N = 200005;
int n, qq;
int a[N];
ll p[N];
void solv()
{
scanf("%d%d", &n, &qq);
for (int i = 1; i <= n; ++i)
scanf("%d", &a[i]);
for (int i = 1; i <= n; ++i)
p[i] = p[i - 1] + a[i];
vector<pair<ll, int> > v;
for (int i = 1; i <= n; ++i)
v.push_back(m_p(p[i], i));
sort(all(v));
vector<int> s(sz(v) + 1);
s[sz(v)] = N;
for (int i = sz(v) - 1; i >= 0; --i)
s[i] = min(s[i + 1], v[i].se);
while (qq--)
{
int x;
scanf("%d", &x);
int i = lower_bound(all(v), m_p(x * 1LL, 0)) - v.begin();
if (s[i] == N)
{
if (p[n] <= 0)
{
printf("-1 ");
continue;
}
ll ans = (x / p[n]) * n + n;
int l = 1, r = (x / p[n]);
while (l <= r)
{
int u = (l + r) / 2;
ll yans = (u * 1LL * n);
ll xx = x;
xx -= u * 1LL * p[n];
int i = lower_bound(all(v), m_p(xx, 0)) - v.begin();
if (s[i] != N)
{
ans = u * 1LL * n + s[i];
r = u - 1;
}
else
l = u + 1;
}
printf("%lld ", ans - 1);
}
else
printf("%d ", s[i] - 1);
}
printf("\n");
}
int main()
{
#ifdef SOMETHING
freopen("input.txt", "r", stdin);
//freopen("output.txt", "w", stdout);
#endif // SOMETHING
//ios_base::sync_with_stdio(false), cin.tie(0);
int tt = 1;
scanf("%d", &tt);
while (tt--)
solv();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define int long long
int get(vector<int> &a, int n, int k)
{
int low = 0, high = n - 1, ans = -1 ;
while (low <= high)
{
int mid = (low + high) / 2;
if (a[mid] >= k)
{
ans = mid + 1;
high = mid - 1;
}
else
low = mid + 1;
}
return ans;
}
void solve()
{
int n, m, sum = 0;
cin >> n >> m;
vector<int> a(n);
for (int i = 0; i < n; ++i)
{
cin >> a[i];
sum += a[i];
a[i] = sum;
if (i)
a[i] = max(a[i], a[i - 1]);
}
for (int i = 0; i < m; ++i)
{
int k;
cin >> k;
int ans = get(a, n, k);
if (ans != -1)
cout << ans - 1 << ' ';
else
{
if (sum <= 0)
cout << -1 << ' ';
else
{
int low = 1, high = k / sum + (k % sum), ans = n * k;
while (low <= high)
{
int mid = (low + high) / 2;
int x = get(a, n, k - mid * sum);
if (x != -1)
{
ans = min(mid * n + x, ans);
high = mid - 1;
}
else
low = mid + 1;
}
cout << ans - 1 << ' ';
}
}
}
cout << '\n';
}
int32_t main(int32_t argc, char const *argv[])
{
int t;
cin >> t;
while (t --)
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef vector<int> vi;
typedef pair<int, int> pii;
typedef vector<ll> vl;
typedef pair<ll, ll> pll;
#define St first
#define Nd second
#define Pb push_back
#define print_pair(p) "{" << (p).St << ", " << (p).Nd << "} "
#define list_format(i, n) (i!=n? " ":"\n")
#define endl "\n"
#define sz(a) (int)a.size()
#define ALL(a) a.begin(), a.end()
#define REP(i,a,b) for(int i = a; i <= b; i++)
#define REV(i,a,b) for(int i = a; i >= b; i--)
#define AritSum(a,d,n) ((n)*(2*(a)+((n)-1)*(d)))/2
#define Log(base, num) log2(num)/log2(base)
#define MOD 1000000007
#define INF 1e9
// ******************** Add-on *****************************
// ******************** Add-on *****************************
// ************* MAIN *******************
void precompute() {}
ll n, m, A[200000], mx[200000];
void solve() {
cin >> n >> m;
ll ma = 0, cur = 0;
REP(i,0,n-1) cin >> A[i], cur += A[i], ma = max(ma, cur), mx[i + 1] = max(mx[i], ma);
REP(i,0,m-1) {
ll x; cin >> x;
ll ans = 0;
if (x > ma && cur <= 0) {
cout << -1 << " ";
continue;
}
if (x > ma) {
ll temp = x - ma;
ll complete = (temp + cur - 1) / cur;
ans += complete * n;
x -= complete * cur;
}
int l = 1, r = n, b = n;
while (l <= r) {
int mid = (l + r)/2;
if (mx[mid] >= x) {
b = mid;
r = mid - 1;
} else l = mid + 1;
}
cout << ans + b - 1 << " ";
}
cout << endl;
}
/*
g++ -std=c++14 -Wall -Wextra -O2 Test.cpp -o Test
./Test < in.txt
*/
int main() {
precompute();
int _=1;
cin>>_;
REP(t,1,_) {
// cout << "Case #" << t << ": ";
solve();
// cout << ((solve())? "YES" : "NO") << endl;
}
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
template <class T> ostream &operator << (ostream &os, const vector<T> &p) { os << "["; for (auto&it : p) os << it << " "; return os << "]";}
template <class S, class T> ostream &operator << (ostream &os, const pair<S, T> &p) { return os << "(" << p.first << "," << p.second << ")";}
#ifndef ONLINE_JUDGE
#define deb(...) dbs(#__VA_ARGS__,__VA_ARGS__)
template <class T> void dbs(string str, T t) { cerr << str << ":" << t << "\n";}
template<class T, class...S> void dbs(string str, T t, S... s) { int idx = str.find(','); cerr << str.substr(0, idx) << ":" << t << ","; dbs(str.substr(idx + 1), s...);}
#else
#define deb(...){}
#endif
#define int long long
#define fi first
#define se second
#define mp make_pair
#define pb push_back
#define rep(i,n) for(int i = 0; i < n; i++)
#define sz(x) (int)x.size()
#define nl cout<< '\n'
#define pr(x) {cout << x << "\n"; return;}
#define all(x) x.begin(), x.end()
#define re(i,n) for(int i = 1; i <= n; i++)
#define prl(x) {cout << x << "\n";}
#define ini(x, y) memset(x, y, sizeof(x))
#define fr(i,a,b) for(int i = a; i <= b; i++)
#define fb(i,a,b) for(int i = a; i >= b; i--)
#define vi vector<int>
#define pii pair<int, int>
#define vii vector<pii>
template<class T> bool umin(T &a, T b) { return a > b ? (a = b, true) : false; }
template<class T> bool umax(T &a, T b) { return a < b ? (a = b, true) : false; }
void solve() {
int n, q; cin >> n >> q;
vi a(n);
int mx = -1e18, sum = 0;
vii v;
map<int, int> m;
rep(i, n) {
int x; cin >> x;
sum += x;
a[i] = x;
if (sum > mx) {
mx = sum;
m[sum] = i + 1;
}
}
deb(v);
while (q--) {
int x; cin >> x;
if (sum > 0) {
int r = (x / sum) * n;
int rem = x % sum;
if (rem > 0) {
auto pos = *m.lower_bound(rem);
r += pos.se;
}
int ans = r;
int l = 0, ri = 1e9;
while (l <= ri) {
int mid = (l + ri) / 2;
int have = mid * sum;
int rem = x - have;
int r = mid * n;
if (mx >= rem) {
if (rem > 0) {
auto pos = *m.lower_bound(rem);
r += pos.se;
}
umin(ans, r);
ri = mid - 1;
} else l = mid + 1;
}
cout << ans - 1 << ' ';
} else if (sum <= 0 && mx >= x) {
int rem = x;
auto pos = m.lower_bound(rem);
auto it = *pos;
deb(it);
int r = it.se;
cout << r - 1 << ' ';
} else cout << "-1 ";
}
nl;
}
signed main() {
ios_base::sync_with_stdio(false), cin.tie(nullptr);
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
int q = 1;
cin >> q;
while (q--) solve();
return 0;
}
|
#include<iostream>
#include<algorithm>
#include<cstring>
#include<map>
using namespace std;
#define ll long long
#define maxn 200005
ll t,n,m,a[maxn],k;
map<ll,ll> v;
ll bs(ll c){
ll l=0,r=k;
while(l<r){
ll m=(l+r)/2;
if(a[m]>=c) r=m;
else l=m+1;
}
if(r==k) return -1;
return v[a[l]];
}
int main(){
cin>>t;
while(t--){
//cout<<' '<<t<<endl;
cin>>n>>m;
ll res=0;
v.clear();k=0;
for(int i=1;i<=n;i++){
ll c;cin>>c;
res+=c;
if(res>=0&&!v[res]){
if(!k||(res>a[k-1])){
v[res]=i;
a[k++]=res;
}
}
}
for(int i=0;i<m;i++){
ll c,p,h=0;cin>>c;
if(res<=0) p=bs(c);
else{
if(c>a[k-1]){
h=(c-a[k-1])/res;
if((c-a[k-1])%res) h+=1;
c-=h*res;
}
p=bs(c);
if(p!=-1) p+=h*n;
}
if(p!=-1) p-=1;
cout<<p<<' ';
}
cout<<endl;
}
return 0;
}
|
#include <bits/stdc++.h>
#define F first
#define S second
#define all(x) x.begin(),x.end()
#define endl '\n'
using namespace std;
using ll = long long;
using pii = pair<int, int>;
const int INF = 0x3f3f3f3f;
const ll INFLL = 0x3f3f3f3f3f3f3f3fLL;
const int MOD = 1000000007;
const int dx[] = { 0, 0, -1, 1, 1, -1, 1, -1};
const int dy[] = {-1, 1, 0, 0, 1, -1, -1, 1};
int main() {
ios_base::sync_with_stdio(false); cin.tie(NULL);
int t;
cin >> t;
while(t--){
int n, m;
cin >> n >> m;
vector<ll> v(n);
for(int i=0; i<n; i++){
cin >> v[i];
}
ll sum = 0, mx=-INFLL;
for(int i=0; i<n; i++){
sum += v[i];
mx = max(mx, sum);
v[i] = mx;
}
for(int i=0; i<m; i++){
ll x;
cin >> x;
if(x <= mx){
ll p = lower_bound(all(v), x) - v.begin();
cout << p << " ";
}else{
if(sum <= 0){
cout << -1 << " ";
}else{
ll y = (x-mx)/sum;
ll ans = y*n;
x -= y*sum;
while(x > mx){
ans += n;
x -= sum;
}
ll p = lower_bound(all(v), x) - v.begin();
cout << ans + p << " ";
}
}
}
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main()
{
int tc;cin>>tc;
while(tc--)
{
int n,m;cin>>n>>m;
vector<int> v(n);
for(int i=0;i<n;i++)cin>>v[i];
vector<long long> ps={v[0]}, ix={0};
long long sp=v[0];
for(int i=1;i<n;i++)
{
sp+=v[i];
if(sp>=ps.back()){ps.push_back(sp);ix.push_back(i);}
}
for(int i=0;i<m;i++)
{
int x;cin>>x;
if(ps.back()<x && sp<=0){cout<<"-1 ";continue;}
long long ts = 0LL;
if(ps.back()<x)ts=(x-ps.back()+sp-1)/sp;
int pos = ix[lower_bound(ps.begin(),ps.end(), x-(sp*1LL*ts))-ps.begin()];
cout<<pos+(ts*(n))<<" ";
}
cout<<endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
typedef unsigned uint;
typedef long long ll;
typedef unsigned long long ull;
typedef long double ldbl;
typedef pair<int, int> pii;
typedef pair<uint, uint> puu;
typedef pair<ll, ll> pll;
typedef pair<ull, ull> pull;
typedef pair<double, double> pdd;
typedef vector<int> vi;
typedef vector<uint> vu;
typedef vector<ll> vll;
typedef vector<ull> vull;
typedef vector<pii> vpii;
typedef vector<puu> vpuu;
typedef vector<pll> vpll;
typedef vector<pull> vpull;
typedef vector<string> vstr;
typedef vector<double> vdbl;
typedef vector<ldbl> vldbl;
#define pb push_back
#define ppb pop_back
#define pfr push_front
#define ppfr pop_front
#define emp emplace
#define empb emplace_back
#define be begin
#define rbe rbegin
#define all(x) (x).be(), (x).end()
#define rall(x) (x).rbe(), (x).rend()
#define fir first
#define sec second
#define mkp make_pair
#define brif(cond) if (cond) break
#define ctif(cond) if (cond) continue
#define retif(cond) if (cond) return
void canhazfast() {ios_base::sync_with_stdio(false);cin.tie(nullptr);cout.tie(nullptr);}
template<typename T> T gcd(T a, T b) {return b ? gcd(b, a%b) : a;}
template<typename T> T extgcd(T a, T b, T &x, T &y)
{
T x0 = 1, y0 = 0, x1 = 0, y1 = 1;
while (b) {
T q = a/b; a %= b; swap(a, b);
x0 -= q*x1; swap(x0, x1);
y0 -= q*y1; swap(y0, y1);
}
x = x0; y = y0; return a;
}
int ctz(uint x) {return __builtin_ctz(x);}
int ctzll(ull x) {return __builtin_ctzll(x);}
int clz(uint x) {return __builtin_clz(x);}
int clzll(ull x) {return __builtin_clzll(x);}
int popcnt(uint x) {return __builtin_popcount(x);}
int popcntll(ull x) {return __builtin_popcountll(x);}
int bsr(uint x) {return 31^clz(x);}
int bsrll(ull x) {return 63^clzll(x);}
#define N 200016
int a[N];
pair<ll, int> hi[N];
void solve()
{
int n, m, k = 0;
ll sum = 0, smx = 0;
cin >> n >> m;
for (int i = 0; i < n; ++i) {
cin >> a[i];
sum += a[i];
if (smx < sum) {
smx = sum;
hi[k++] = mkp(sum, i);
}
}
for (; m; --m) {
int x;
ll ans = 0;
cin >> x;
if (x > smx) {
if (sum <= 0) {
cout << "-1 ";
continue;
}
ll d = x-smx;
int q = (d-1)/sum+1;
ans = (ll)q*n;
x -= q*sum;
}
ans += lower_bound(hi, hi+k, mkp((ll)x, 0))->sec;
cout << ans << ' ';
}
cout << '\n';
}
int main()
{
canhazfast();
int t;
cin >> t;
for (; t; --t) solve();
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
ll a[200010];
ll x[200010];
ll sa[200010];
ll sama[200010];
int psama[200010];
inline ll read(){
ll f=1,x=0;char ch;
do{ch=getchar();if(ch=='-')f=-1;}while(!isdigit(ch));
do{x=x*10+ch-'0';ch=getchar();}while(isdigit(ch));
return f*x;
}
int main(){
ll t;
cin>>t;
while(t--){
ll n,m;cin>>n>>m;
for(ll i=1;i<=n;i++)a[i]=read();
for(ll i=0;i<m;i++)x[i]=read();
for(ll i=1;i<=n;i++)sa[i]=sa[i-1]+a[i];
for(int i=1;i<=n;i++){
if(sama[i-1]<sa[i]){
sama[i]=sa[i];
psama[i]=i;
}else{
sama[i]=sama[i-1];
psama[i]=psama[i-1];
}
}
ll rd=sa[n];
for(ll i=0;i<m;i++){
if(rd<=0){
if(sama[n]<x[i])cout<<-1<<' ';
else {
int lop=lower_bound(sama+1,sama+1+n,x[i])-sama;
cout<<psama[lop]-1<<' ';
}
}else {
if(sama[n]<x[i]){
ll tmp=x[i]-sama[n];
ll tcp;
if(tmp%rd==0)tcp=tmp/rd;
else tcp=tmp/rd+1;
int lop=lower_bound(sama+1,sama+1+n,x[i]-tcp*rd)-sama;
cout<<n*tcp+psama[lop]-1<<' ';
}else{
int lop=lower_bound(sama+1,sama+1+n,x[i])-sama;
cout<<psama[lop]-1<<' ';
}
}
}
cout<<endl;
}
}
//author: caramel_pudding
|
#include<iostream>
#include<algorithm>
using namespace std;
const int N=2e6+5;
typedef long long ll;
long long n,m;
long long a[N],s[N],v[N],id[N];
int main(){
int t;
scanf("%d",&t);
while(t--){
scanf("%lld%lld",&n,&m);
for(int i=0;i<=n;i++)s[i]=v[i]=0;
ll tot=0;
for(int i=1;i<=n;i++){
scanf("%lld",&a[i]);
s[i]=s[i-1]+a[i];
if(!tot||s[i]>v[tot]) v[++tot]=s[i],id[tot]=i;
}
while(m--){
ll q;
scanf("%lld",&q);
if(q>v[tot]&&s[n]<=0)puts("-1 ");//公式：r*s[n]+max{s[i]}>=q 由于延长后的序列是单调的，所以当 s[n]<=0，截距max{s[i]}<q时公式无解
else{
int r=0;
if(v[tot]<q)//r*s[n]>=q-max{s[i]},max{s[i]}<q时r>=1
r=(q-v[tot]+s[n]-1)/s[n];// 向下取整
q-=r*s[n];
printf("%lld ",r*n+id[lower_bound(v+1,v+1+tot,q)-v]-1);//二分
}
}
puts("");
}
return 0;
}
|
/***************************/
/** Author : thantrongtri3 */
/***************************/
#include <bits/stdc++.h>
using namespace std;
namespace IO{
void setIn(string s) {freopen(s.c_str(), "r", stdin);}
void setOut(string s) {freopen(s.c_str(), "w", stdout);}
void setIO(string s = ""){
ios_base::sync_with_stdio(false);
cin.tie(0); cout.tie(0);
#ifndef ONLINE_JUDGE
cin.exceptions(cin.failbit);
#endif // ONLINE_JUDGE
if (s.size()){
setIn(s+".inp");
setOut(s+".out");
} else{
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
#endif // ONLINE_JUDGE
}
}
}
using namespace IO;
namespace Function{
template <typename T1, typename T2> bool amax(T1 &a, T2 b){
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <typename T1, typename T2> bool amin(T1 &a, T2 b){
if (a > b){
a = b;
return 1;
}
return 0;
}
template <typename T> void compress(T &a){
sort(a.begin(), a.end());
a.resize(unique(a.begin(), a.end()) - a.begin());
}
template <typename T1, typename T2, typename T3> int position(T1 Begin, T2 End, T3 val, bool type = 0){
if (type == 0){
return lower_bound(Begin, End, val) - Begin;
}
return upper_bound(Begin, End, val) - Begin;
}
template <typename T> long long sqr(T x) {return 1LL * x * x;}
template <typename T1, typename T2> long long GCD(T1 a, T2 b) {return b == 0 ? a : GCD(b, a % b);}
template <typename T1, typename T2> long long LCM(T1 a, T2 b) {return 1LL * a / GCD(a, b) * b;}
}
using namespace Function;
namespace Output{
char End_Of_Stream = '\n';
void print(int x) {cout << x << End_Of_Stream;}
void print(unsigned int x) {cout << x << End_Of_Stream;}
void print(long unsigned int x) {cout << x << End_Of_Stream;}
void print(long long x) {cout << x << End_Of_Stream;}
void print(unsigned long long x) {cout << x << End_Of_Stream;}
void print(float x) {cout << x << End_Of_Stream;}
void print(double x) {cout << x << End_Of_Stream;}
void print(long double x) {cout << x << End_Of_Stream;}
void print(char x) {cout << x << End_Of_Stream;}
void print(const char* x) {cout << x << End_Of_Stream;}
void print(string x) {cout << x << End_Of_Stream;}
void print(bool x) {cout << x << End_Of_Stream;}
template <typename T1, typename T2> void print(pair <T1, T2> a) {cout << a.first << " " << a.second << End_Of_Stream;}
template <size_t sz> void print(bitset<sz> a) {
for(int i = 0; i < sz; i++){
cout << a[i];
}
cout << End_Of_Stream;
}
template <typename T> void write(T x) {print(x);}
template <class T, class... Ts> void write(T t, Ts... ts){
write(t);
write(ts...);
}
template <class T, class... Ts> void print(T t, Ts... ts){
End_Of_Stream = ' ';
write(t, ts...);
cout << '\n';
End_Of_Stream = '\n';
}
template <typename T> void print(T a){
for(auto it : a){
print(it);
}
}
template <class T, class... Ts> void prine(T t, Ts... ts){
print(t, ts...);
exit(0);
}
}
using namespace Output;
typedef pair <long long, int> pii;
const int dx[] = {1, -1, 0, 0};
const int dy[] = {0, 0, 1, -1};
const int INF = 1e9 + 10;
const long long INFL = 1e18;
const int MOD = 1e9 + 7;
const int N = 2e5 + 10;
long long sum[N];
int main()
{
setIO();
int T;
cin >> T;
while (T--){
int n, m;
cin >> n >> m;
long long mx = 0;
vector<pii> ans;
for(int i = 1; i <= n; i++){
int x;
cin >> x;
sum[i] = sum[i - 1] + x;
if (sum[i] > mx){
mx = sum[i];
ans.push_back({sum[i], i - 1});
}
}
End_Of_Stream = ' ';
while (m--){
long long x;
cin >> x;
if (sum[n] <= 0){
int res = position(ans.begin(), ans.end(), pii(x, -1));
print(res == ans.size() ? -1 : ans[res].second);
} else {
int l = 0;
int r = INF / sum[n] + 10;
while (l < r){
int mid = (l + r) >> 1;
long long S = 1LL * sum[n] * mid;
if (S + mx < x){
l = mid + 1;
} else {
r = mid;
}
}
if (r == INF / sum[n] + 10){
print(-1);
continue;
}
long long S = 1LL * sum[n] * r;
x -= S;
if (x <= 0){
print(1LL * r * n);
continue;
}
int res = position(ans.begin(), ans.end(), pii(x, -1));
print(ans[res].second + 1LL * r * n);
}
}
End_Of_Stream = '\n';
print("");
}
return 0;
}
|
#include <iostream>
#include <bits/stdc++.h>
#define IOS \
ios::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
#define endl "\n"
#define int long long
#define all(a) a.begin(), a.end()
#define forn(i, N) for (int i = 0; i < N; i++)
#define forab(i, a, b) for (int i = a; i < b; i++)
#define print(x) \
for (auto i : x) \
cout << i << ' '; \
cout << endl;
using namespace std;
int N, i, T, M, a, b, c, d;
int give_time(int val, vector<int> &max_A)
{
return lower_bound(all(max_A), val) - max_A.begin();
}
int give_time(int val, int sigma, int mx, vector<int> &A, vector<int> &max_A)
{
if (sigma <= 0)
{
if (val > mx)
return -1;
return give_time(val, max_A);
}
int n;
if (val <= mx)
n = 0;
else
n = ceil(double((val - mx)) / double(sigma));
val -= n * sigma;
return give_time(val, max_A) + n * A.size();
}
void solve()
{
cin >> N >> M;
vector<int> A(N);
vector<int> X(M);
vector<int> max_A(N);
for (int &i : A)
cin >> i;
for (int &i : X)
cin >> i;
int sig = 0;
int mx = INT_MIN;
int index = 0;
for (int i : A)
{
sig += i;
mx = max(mx, sig);
max_A[index++] = mx;
}
for (int i : X)
{
cout << give_time(i, sig, mx, A, max_A) << " ";
}
cout << endl;
}
int32_t main()
{
IOS;
cin >> T;
while (T--)
solve();
return 0;
}
|
#include <bits/stdc++.h>
#define all(v) v.begin(), v.end()
#define rall(v) v.rbegin(), v.rend()
#define rep(i,n) for (int i=0;i<(int)(n);i++)
#define codefor int test;scanf("%d",&test);while(test--)
#define INT(...) int __VA_ARGS__;in(__VA_ARGS__)
#define LL(...) ll __VA_ARGS__;in(__VA_ARGS__)
#define yes(ans) if(ans)printf("yes\n");else printf("no\n")
#define Yes(ans) if(ans)printf("Yes\n");else printf("No\n")
#define YES(ans) if(ans)printf("YES\n");else printf("NO\n")
#define vector1d(type,name,...) vector<type>name(__VA_ARGS__)
#define vector2d(type,name,h,...) vector<vector<type>>name(h,vector<type>(__VA_ARGS__))
#define umap unordered_map
#define uset unordered_set
using namespace std;
using ll = long long;
const int MOD=1000000007;
const int MOD2=998244353;
const int INF=1<<30;
const ll INF2=(ll)1<<60;
//入力系
void scan(int& a){scanf("%d",&a);}
void scan(long long& a){scanf("%lld",&a);}
template<class T,class L>void scan(pair<T, L>& p){scan(p.first);scan(p.second);}
template<class T> void scan(T& a){cin>>a;}
template<class T> void scan(vector<T>& vec){for(auto&& it:vec)scan(it);}
void in(){}
template <class Head, class... Tail> void in(Head& head, Tail&... tail){scan(head);in(tail...);}
//出力系
void print(const int& a){printf("%d",a);}
void print(const long long& a){printf("%lld",a);}
void print(const double& a){printf("%.15lf",a);}
template<class T,class L>void print(const pair<T, L>& p){print(p.first);putchar(' ');print(p.second);}
template<class T> void print(const T& a){cout<<a;}
template<class T> void print(const vector<T>& vec){if(vec.empty())return;print(vec[0]);for(auto it=vec.begin();++it!= vec.end();){putchar(' ');print(*it);}}
void out(){putchar('\n');}
template<class T> void out(const T& t){print(t);putchar('\n');}
template <class Head, class... Tail> void out(const Head& head,const Tail&... tail){print(head);putchar(' ');out(tail...);}
//デバッグ系
template<class T> void dprint(const T& a){cerr<<a;}
template<class T> void dprint(const vector<T>& vec){if(vec.empty())return;cerr<<vec[0];for(auto it=vec.begin();++it!= vec.end();){cerr<<" "<<*it;}}
void debug(){cerr<<endl;}
template<class T> void debug(const T& t){dprint(t);cerr<<endl;}
template <class Head, class... Tail> void debug(const Head& head, const Tail&... tail){dprint(head);cerr<<" ";debug(tail...);}
ll intpow(ll a, ll b){ ll ans = 1; while(b){ if(b & 1) ans *= a; a *= a; b /= 2; } return ans; }
ll modpow(ll a, ll b, ll p){ ll ans = 1; while(b){ if(b & 1) (ans *= a) %= p; (a *= a) %= p; b /= 2; } return ans; }
ll updivide(ll a,ll b){if(a%b==0) return a/b;else return (a/b)+1;}
template<class T> void chmax(T &a,const T b){if(b>a)a=b;}
template<class T> void chmin(T &a,const T b){if(b<a)a=b;}
int main(){
codefor{
INT(n,m);
ll minv=0,cycle,l,r,mid,index;
vector<ll> a(n),b(m),sumv(n,0),ans(m,-1);
in(a,b);
sumv[0]=a[0];
for(int i=1;i<n;i++){
sumv[i]=sumv[i-1]+a[i];
}
cycle=sumv[n-1];
minv=a[0];
for(int i=0;i<n;i++){
chmax(sumv[i],minv);
chmax(minv,sumv[i]);
}
rep(i,m){
mid=(lower_bound(all(sumv),b[i])-sumv.begin());
if(mid<n){
ans[i]=mid;
continue;
}else if(cycle<=0){
continue;
}
l=0,r=(INF2/(16*cycle));
ans[i]=INF2;
while(l<r){
mid=(l+r)/2;
index=(lower_bound(all(sumv),b[i]-cycle*mid)-sumv.begin());
if(index<n){
if(mid<=INF2/n)chmin(ans[i],(ll)index+n*mid);
r=mid;
}else l=mid+1;
}
/*debug("{",l);
ans[i]=(lower_bound(all(sumv),b[i]-cycle*(l-1))-sumv.begin())+(l-1)*n;*/
}
out(ans);
}
}
|
#include <bits/stdc++.h>
#define pb push_back
typedef long long ll;
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n, m;
cin >> n >> m;
vector <ll> vec(n);
vector <pair<ll, int>> add;
ll sum1 = 0, sum2 = 0;
for (int i = 0; i < n; ++i) {
cin >> vec[i];
sum1 += vec[i];
if (sum1 > sum2) {
add.pb({sum1, i});
sum2 = sum1;
}
}
vector <ll> add2;
for (auto it : add)
add2.pb(it.first);
while (m--) {
ll x;
cin >> x;
int pos = lower_bound(add2.begin(), add2.end(), x) - add2.begin();
if (pos < add2.size())
cout << add[pos].second << " ";
else {
if (sum1 <= 0)
cout << -1 << " ";
else {
ll l = 1, r = 2e9;
ll ans2 = -1;
while (l <= r){
ll mid = (l + r) >> 1;
ll temp = x - mid * sum1;
ll ans = n * mid - 1;
bool f = true;
if (temp > 0){
int pos = lower_bound(add2.begin(), add2.end(), temp) - add2.begin();
if (pos < add2.size())
ans += add[pos].second + 1;
else
f = false;
}
if (f){
ans2 = ans;
r = mid - 1;
}
else
l = mid + 1;
}
cout << ans2 << " ";
}
}
}
cout << endl;
}
}
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn=2e5+50;
ll n,m,T,a[maxn],sum[maxn],maxx[maxn],ans[maxn];
int main(){
cin>>T;
while(T--){
cin>>n>>m;
for(int i=1;i<=n;i++)cin>>a[i],sum[i]=sum[i-1]+a[i],maxx[i]=max(maxx[i-1],sum[i]);
for(int i=1;i<=m;i++){
ll x;cin>>x;
if(x<=maxx[n]){
cout<<lower_bound(maxx+1,maxx+1+n,x)-maxx-1<<' ';
}
else{
if(sum[n]<=0){
cout<<-1<<' ';
}
else{
ll d=x-maxx[n];
ll tot=ceil(d*1.0/sum[n]);
x-=tot*sum[n];
ll t=lower_bound(maxx+1,maxx+1+n,x)-maxx;
t=t+tot*n-1;
cout<<t<<' ';
}
}
}
cout<<endl;
}
return 0;
}
|
#include<iostream>
#include<bits/stdc++.h>
using namespace std;
//read domain
typedef long long ll;
int dp[200001][2];
void build(int l, int r, vector<int> const &a, vector<int> &d, int curD = 0) {
if (r < l) {
return;
}
if (l == r) {
d[l] = curD;
return;
}
int m = l;
for (int i = l + 1; i <= r; i++) {
if (a[m] < a[i]) {
m = i;
}
}
d[m] = curD;
build(l, m - 1, a, d, curD + 1);
build(m + 1, r, a, d, curD + 1);
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
#ifndef ONLINE_JUDGE
// cout << "hh" << endl;
freopen("new_inp2.txt", "r", stdin);
freopen("okk.txt", "w", stdout);
#endif
ll chk[10001];
int t;
cin >> t;
while (t--)
{ //cout << "yes" << endl;
ll n, m;
cin >> n >> m;
set<pair<ll, ll>> st;
vector<ll> vect;
ll sum = 0, mxx = INT_MIN;
for (int i = 0; i < n; i++)
{
int x;
cin >> x;
vect.push_back(x);
sum += x;
if (mxx < sum)
{
mxx = sum;
st.insert({sum, i});
// cout << sum << " " << i << endl;
}
}
// for (auto i : vect)
// {
// cout << i << " ";
// }
// cout << endl;
//cout << "yo" << endl;
while (m--)
{
ll x;
cin >> x;
// cout << st.size() << "I am" << x << endl;
ll round = 0;
if (sum <= 0 && st.rbegin()->first < x)
{
cout << "-1" << " ";
continue;
}
if (mxx < x)
{
ll temp = x - mxx;
round = temp / sum + (temp % sum == 0 ? 0 : 1);
x -= round * sum;
}
auto index = st.lower_bound({x, -1});
//cout << round << "dd" << x << " " << index->second << endl;
cout << index->second + round*n << " ";
}
cout << endl;
}
}
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
int arr[200005];
ll nax,nim;
int n,m;
ll max(ll a,ll b){
return (a<b)?b:a;
}
ll min(ll a,ll b){
return (a<b)?a:b;
}
int main(){
int t;cin>>t;
while(t--){
cin>>n>>m;
ll nax=LONG_MIN;
ll s=0;
set<pair<ll,ll>> record;
for(int i=1;i<=n;i++){
cin>>arr[i];
s+=arr[i];
if(s>nax){
nax=s;
record.insert(make_pair(nax,i-1));
}
}
while(m--){
int x;cin>>x;
if(s<=0&&x>nax){
cout<<"-1 ";continue;
}
int round=0;
if(nax<x){
int k=x-nax+s-1;
round=k/s;
x=x-round*s;
}
auto k=record.lower_bound(make_pair(x,-1));
cout<<round*1ll*n+(*k).second<<" ";
}
cout<<"\n";
}
}
|
#include <algorithm>
#include <cmath>
#include <iostream>
#include <limits>
#include <map>
#include <queue>
#include <set>
#include <stdlib.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;
#pragma GCC optimize("O2", "O3", "fast")
#define _9trash no WA
#define ll long long
#define pb push_back
void io() {
ios_base::sync_with_stdio(0);
cin.tie(0);
}
// -------------------------------------------------------------
ll n, x, a[200010], sum, mx;
ll cur, cnt, re;
vector<pair<int, ll>> v;
ll solve() {
if (x > mx && sum <= 0)
return -1;
cur = cnt = 0;
if (x > mx)
cnt = (x - mx + sum - 1) / sum;
re = x - cnt * sum;
int l = 0, r = v.size();
while (l < r) {
int mid = (l + r) / 2;
if (v[mid].second >= re)
r = mid;
else
l = mid + 1;
}
return cnt * n + v[l].first;
}
int t, m;
signed main() {
io();
cin >> t;
while (t--) {
v.clear();
cin >> n >> m;
sum = 0, mx = -2e9;
for (int i = 0; i < n; i++) {
cin >> a[i];
sum += a[i];
if (sum > mx) {
mx = sum;
v.pb({i, mx});
}
}
for (int i = 0; i < m; i++) {
cin >> x;
cout << solve() << " ";
}
cout << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
#define pb push_back
#define fi first
#define se second
#define all(X) (X).begin(),(X).end()
#define ln "\n"
#define out cout
#define NON_TOGLIERE ios_base::sync_with_stdio(0); cin.tie(0);
#define ll long long
#define VI vector<int>
#define pii pair<int,int>
#define pll pair<long long,long long>
#define PQ priority_queue
#define sz(v) ((int)v.size())
#define inf 1000000001
#define maxn 200010
using namespace std;
#if ONLINE_JUDGE
#define in cin
#else
ifstream in("input.txt");
#endif
ll n,i,Q,T,j,k,m,t,x,y,mam,v[maxn],s[maxn],q[maxn],p[maxn];
int main(){
NON_TOGLIERE
in>>Q;
for(T=1;T<=Q;T++){
in>>n>>m;mam=0;ll fine=0;
vector<pll>kek;
for(i=0;i<n;i++)in>>v[i];
s[0]=mam=v[0];
if(v[0]>0)kek.pb({v[0],0ll});
for(i=1;i<n;i++){
s[i]=v[i]+s[i-1];
if(s[i]>mam){
mam=s[i];
kek.pb({mam,i});
}
}
//for(auto y:kek)cout<<y.fi<<" ";out<<ln;
for(i=0;i<m;i++){
fine=0;
in>>x;
if(x>mam&&s[n-1]<=0){
cout<<-1<<" ";continue;
}
if(x>mam){//cout<<x<<ln;
k=x-mam;
k=(k-1+s[n-1])/s[n-1];
x-=k*s[n-1];
fine+=n*k;
}
if(x==0){
cout<<fine<<" "; continue;
}
pll tmp={x,0ll};
auto ind=lower_bound(all(kek),tmp);
int cel=(int)(ind-kek.begin());
fine+=kek[cel].se;
cout<<fine<<" ";
}
out<<ln;
}
}
|
#include <bits/stdc++.h>
#define x first
#define y second
using namespace std;
typedef pair<int, int> PII;
typedef pair<double, double> PDD;
typedef long long LL;
const int N = 200010;
int n, m;
LL a[N];
LL s[N];
struct Stack
{
LL s, id;
}stk[N];
int main()
{
int t;
cin >> t;
while (t -- )
{
cin >> n >> m;
LL maxv = 0, sum = 0;
for (int i = 1; i <= n; i ++ )
{
cin >> a[i];
sum += a[i];
s[i] = s[i - 1] + a[i];
if (i != n) maxv = max(maxv, s[i]);
}
int tt = 0;
for (int i = 0; i <= n - 1; i ++ )
{
if (!tt || stk[tt].s < s[i]) stk[ ++ tt] = {s[i], i};
}
while (m -- )
{
LL x;
cin >> x;
if (maxv < x && sum <= 0)
{
cout << -1 << ' ';
continue;
}
LL T = 0;
if (sum > 0) T = max(T, (x - maxv + sum - 1) / sum);
x -= T * sum;
int l = 1, r = tt;
while (l < r)
{
int mid = l + r >> 1;
if (stk[mid].s >= x) r = mid;
else l = mid + 1;
}
cout << ((LL)T * n + stk[l].id - 1) << ' ';
}
cout << endl;
}
return 0;
}
|
//#include <atcoder/all>
//using namespace atcoder;
//using mint = modint;
#include <bits/stdc++.h>
#define int long long
#define sint signed
#define endl "\n" // fflush(stdout);
#define ALL(v) (v).begin(),(v).end()
#define Vi vector<int>
#define VVi vector<Vi>
#define VVVi vector<VVi>
#define Vm vector<mint>
#define VVm vector<Vm>
#define Vs vector<string>
#define Vd vector<double>
#define Vc vector<char>
#define Pii pair<int,int>
#define Pdd pair<double,double>
#define VPii vector<Pii>
#define Tiii tuple<int,int,int>
#define VTiii vector<Tiii>
#define PQi priority_queue<int>
#define PQir priority_queue<int,vector<int>,greater<int>>
#define pb push_back
#define mp make_pair
#define mt make_tuple
#define itos to_string
#define stoi stoll
#define FI first
#define SE second
#define cYES cout<<"YES"<<endl
#define cNO cout<<"NO"<<endl
#define cYes cout<<"Yes"<<endl
#define cNo cout<<"No"<<endl
#define cyes cout<<"yes"<<endl
#define cno cout<<"no"<<endl
#define sortr(v) sort(v,greater<>())
#define rep(i,a,b) for(int i=a;i<b;i++)
#define repeq(i,a,b) for(int i=a;i<=b;i++)
#define repreq(i,a,b) for(int i=a;i>=b;i--)
#define dem(a,b) ((a+b-1)/(b))
#define INF 3000000000000000000 // 3.0*10^18
#define MAX LLONG_MAX
#define PI acos(-1.0L)
using namespace std;
/* debug */
template <typename T>
ostream& operator<<(ostream& os,const vector<T> &V){int N=V.size();
if(N==0){os<<'.';return os;}rep(i,0,N-1){os<<V[i]<<' ';}os<<V[N-1];return os;}
template <typename T>
ostream& operator<<(ostream& os,const vector<vector<T>> &V){
int N=V.size();rep(i,0,N-1)os<<V[i]<<endl;os<<V[N-1];return os;}
template <typename T,typename S>
ostream& operator<<(ostream& os, pair<T,S> const&P){os<<P.FI<<' '<<P.SE;return os;}
//ostream& operator<<(ostream& os, mint const&M){os<<M.val();return os;}
/* useful */
template<typename T>void Vin(vector<T> &v){int n=v.size();rep(i,0,n)cin>>v[i];}
int scomb(int n, int r){if(r<0||r>n)return 0;if((n-r)<r)r=n-r; // nCr
int a=1;for(int i=n;i>n-r;--i){a=a*i;}for(int i=1;i<r+1;++i){a=a/i;}return a;}
int digit_sum(int n){int ret=0; while(n>0){ret+=n%10;n/=10;}return ret;}
int digit(int k,int i){string s = itos(k);return s[s.size()-i]-'0';}
template<typename T>void press(T &v){v.erase(unique(ALL(v)),v.end());}
int SMALLER(Vi &a,int x){return lower_bound(a.begin(),a.end(),x)-a.begin();}
int orSMALLER(Vi &a,int x){return upper_bound(a.begin(),a.end(),x)-a.begin();}
int BIGGER(Vi &a,int x){return a.size()-orSMALLER(a,x);}
int orBIGGER(Vi &a,int x){return a.size()-SMALLER(a,x);}
int COUNT(Vi &a,int x) {return upper_bound(ALL(a),x)-lower_bound(ALL(a),x);}
int maxind(Vi &a){return max_element(ALL(a))-a.begin();}
int minind(Vi &a){return min_element(ALL(a))-a.begin();}
template<typename T>bool chmax(T &a,T b) {if(a<b){a=b;return 1;}return 0;}
template<typename T>bool chmin(T &a,T b) {if(a>b){a=b;return 1;}return 0;}
/*
Vi zip(Vi b){int Z=b.size();
Pii p[Z+10];int a=b.size();Vi l(a);for(int i=0;i<a;i++)
p[i]=mp(b[i],i);sort(p,p+a);int w=0;for(int i=0;i<a;i++)
{if(i&&p[i].first!=p[i-1].first)w++;l[p[i].second]=w;}return l;}
*/
Vi vis(Vi &v){Vi S(v.size()+1);rep(i,1,S.size())S[i]+=v[i-1]+S[i-1];return S;}
//const int MOD = 998244353;
const int MOD = 1000000007;
const double EPS = 1e-10;
void init(){cin.tie(0);cout.tie(0);ios::sync_with_stdio(0);
cout<<fixed<<setprecision(12);//mint::set_mod(MOD);
}
/************************************ START ************************************/
void sol() {
int n,m;cin >> n >> m;
Vi a(n),x(m);Vin(a);Vin(x);
int sum = 0;
rep(i,0,n) {
sum += a[i];
}
Vi b = vis(a);
int maxx = -INF;
rep(i,0,b.size()) {
chmax(maxx,b[i]);
b[i] = maxx;
}
//cout << b << endl;
Vi pre(m);
rep(i,0,m) {
if(sum <= 0) {
int ans = SMALLER(b,x[i]);
if(ans > n) pre[i] = -1;
else pre[i] = ans-1;
}
else {
int ans = 0;
int kai = 0,sa = 0;
if(x[i] > maxx) {
sa = x[i]-maxx;
kai = dem(sa,sum);
ans += kai*n;
x[i] -= kai*sum;
}
ans += SMALLER(b,x[i])-1;
pre[i] = ans;
}
}
cout << pre << endl;
}
signed main() {
init();
int q = 1;
cin >> q;
while(q--) sol();
return 0;
}
|
//in dp prefix suffix sum helps..
#include<iostream>
#include<vector>
#include<string.h>
#include<algorithm>
#include<iomanip>
#include<cmath>
#include<stack>
#include <iterator>
#include <map>
#include<list>
#include <fstream>
#include<unordered_map>
#include<set>
#include<queue>
#define int long long
#define double long double
#define pb push_back
#define mp make_pair
#define pii pair<int,int>
#define pip pair<int, pair<int, int> >
#define viv vector<vector<int> >
#define vip vector< pair<int, int> >
#define vi vector<int>
#define mii map<int, int>
#define qu queue<int>
#define set set<int>
#define multi multiset<int>
#define stack stack<int>
#define fi first
#define se second
#define reverse(s) reverse(s.begin(), s.end())
#define sort1(v) sort(v.begin(), v.end())
#define it iterator
#define pq1 priority_queue <pii, vector<pii>, greater<pii> >
#define mem(x, y) memset(x, (int)y, sizeof(x))
#define ps(x,y) fixed<<setprecision(y)<<x
// author :: Anurag Anand.
using namespace std;
int z= 1e9+7;
//int z= 998244353;
int gcd(int a, int b){
if(a==0)return b;
if(b==0)return a;
return gcd(b, a%b);
}
int power(int a,int b)
{
int res=1;
while(b)
{
if(b&1)
{
res=(res*a)%z;
b--;
}
else
{
a=(a*a)%z;
b=b>>1;
}
}
return res;
}
vi sieve;
// vi seg;
// void arrange(int i, int v, int x, int lx, int rx){
// if(rx-lx==1){
// seg[x] =v;
// return;
// }
// int m= (lx+rx)/2;
// if(i<m){
// arrange(i, v, 2*x+1, lx, m);
// }
// else arrange(i, v, 2*x+2, m, rx);
// seg[x]=seg[2*x+1]+seg[2*x+2];
// }
// int calc(int l, int r, int x, int lx, int rx){
// if(l>=rx||r<=lx) return 0;
// if(lx>=l&&rx<=r) return seg[x];
// int mid=(lx+rx)/2;
// int sl= calc(l, r, 2*x+1, lx, mid), sr= calc(l, r, 2*x+2, mid, rx);
// return sl+sr;
// }
int32_t main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
vi pp;
pp.assign(1000001, 0);
for(int i=2;i<1000;i++){
if(!pp[i]){
for(int j=i*i;j<=1000000;j+=i){
pp[j]=1;
}
}
}
for(int i=2;i<=1000000;i++) if(!pp[i]) sieve.pb(i);
int t;
t=1;
cin>>t;
while(t--){
int n, m;
cin>>n>>m;
int ar[n], ans[m];
for(int i=0;i<n;i++) cin>>ar[i];
for(int i=1;i<n;i++) ar[i]+=ar[i-1];
int sum=ar[n-1];
vip v;
for(int i=0;i<n;i++){
v.pb(mp(ar[i], i));
}
sort1(v);
for(int i=n-2;i>=0;i--){
if(v[i].se>v[i+1].se) v[i].se= v[i+1].se;
}
int mx=v[n-1].fi;
for(int i=0;i<m;i++){
int x;
cin>>x;
int l=0, r=n-1, a=-1;
while(l<=r){
int mid=(l+r)/2;
if(v[mid].fi>=x){
a=mid;
r= mid-1;
}
else l= mid+1;
}
if(a!=-1) ans[i]= v[a].se;
else{
if(sum<=0) ans[i]=-1;
else{
int k= (x-mx)/sum;
if((x-mx)%sum) k++;
x-=k*sum;
l=0, r=n-1, a=-1;
while(l<=r){
int mid=(l+r)/2;
if(v[mid].fi>=x){
a=mid;
r= mid-1;
}
else l= mid+1;
}
ans[i]= v[a].se+k*n;
}
}
}
for(int i=0;i<m;i++) cout<<ans[i]<<" ";
cout<<"\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define t64 int64_t
#define rep(i,a,b) for(int i=a;i<b;i++)
#define FOR(i,a,b) for(int i=a;i<b;i++)
#define FORe(i,a,b) for(int i=a;i<=b;i++)
#define FORr(i,a,b) for(int i=a;i>b;i--)
#define FORre(i,a,b) for(int i=a;i>=b;i--)
#define pb push_back
#define imie(...) " [" << #__VA_ARGS__ ": " << (__VA_ARGS__) << "] "
const ll inf = 1e9+7;
t64 ceil_div(t64 a,t64 b){
t64 ans = a/b;
if(a%b != 0)ans++;
return ans;
}
void solve(){
int n,m; cin >> n >> m;
vector<t64>a(n);
vector<t64>pref(n);
vector<pair<t64,int> > maxes;
rep(i,0,n){
cin >> a[i];
}
pref[0] = a[0];
maxes.pb(pair<t64,int>(a[0],0));
rep(i,1,n){
pref[i] = pref[i-1]+a[i];
if(pref[i] > maxes.back().first){
maxes.pb(pair<t64,int>(pref[i],i));
}
}
t64 x;
rep(i,0,m){
cin >> x;
t64 ans = 0;
if(x <= maxes.back().first){
// cout << "C1\n";
ans = lower_bound(maxes.begin(),maxes.end(),pair<t64,int>(x,0))->second + 1;
}
else{
if(pref[n-1] <= 0){
// cout << "C2\n";
ans = 0;}
else{
t64 aux = x - maxes.back().first;
t64 num = ceil_div(aux,pref[n-1]);
x -= (num * pref[n-1]);
ans = num * n;
ans += lower_bound(maxes.begin(),maxes.end(),pair<t64,int>(x,0))->second + 1;
}
}
cout << ans -1 << " ";
}
cout << endl;
}
void solve2(){
int n,m; cin >> n >> m;
t64 total_sum = 0;
t64 highest_sum = 0;
int highest_sum_moves = 0;
map<t64,int> sums;
vector<t64> a(n);
rep(i,0,n){
cin >> a[i];
total_sum += a[i];
if(sums[total_sum] == 0){
sums[total_sum] = i;
}
highest_sum = max(highest_sum,total_sum);
if(total_sum > highest_sum){
highest_sum = total_sum;
highest_sum_moves = i;
}
}
vector<t64> x(m); rep(i,0,m) cin >> x[i];
// cout << imie(total_sum) << endl;
if(total_sum <= 0){
for(auto v: x){
if(v > highest_sum){
cout << -1 << " ";
}
else{
int ans = inf;
map<t64,int>::iterator it;
for(it = sums.end()--;it != sums.begin(); it--){
if(it->first >= v){
ans = min(ans, it->second);
}
else break;
}
if(it->first >= v){
ans = min(ans, it->second);
}
cout << ans << " ";
}
}
cout << endl;
}
else{
for(auto v: x){
int pre = 0;
if(v > highest_sum){
pre += n-1;
v -= highest_sum;
}
while(v > highest_sum){
pre += n;
v -= highest_sum;
}
// cout << imie(pre) << imie(v) << endl;
int ans = inf;
map<t64,int>::iterator it;
for(it = sums.end()--;it != sums.begin(); it--){
if(it->first >= v){
if(pre != 0){
ans = min(ans,1+pre + it->second);
}
else{
ans = min(ans,pre + it->second);
}
}
else break;
}
if(it->first >= v){
if(pre != 0){
ans = min(ans,1+pre + it->second);
}
else{
ans = min(ans,pre + it->second);
}
}
cout << ans << " ";
}
cout << endl;
}
}
int main(){
ios::sync_with_stdio(0);
cin.tie(0);
int t = 1;
cin >> t;
while(t--){
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
#define w(x) int x; cin >> x; while(x--)
#define endl '\n'
#define mod 1000000007
#define ll long long
using namespace std;
ll pow(ll x, ll y, ll p) {
ll res = 1;
x = x % p;
if(x == 0)
return 0;
while(y > 0) {
if(y & 1)
res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
ll _pow(ll a, ll b) {
if(!b)
return 1;
ll temp = _pow(a, b / 2);
temp = temp * temp;
if(b & 1)
return a * temp;
return temp;
}
ll invmod(ll a, ll m) {
return pow(a, m - 2, m);
}
ll cl(ll a, ll x) {
return a % x == 0 ? a / x : a / x + 1;
}
int main() {
ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
w(t) {
ll n, m, sum = 0;
cin >> n >> m;
vector<ll> v(n), q(m);
vector<pair<ll, ll>> pre;
for(int i = 0; i < n; i++) {
cin >> v[i];
sum += v[i];
if(sum > 0) {
if(pre.empty() || pre.back().first < sum)
pre.push_back({sum, i});
}
}
for(int i = 0; i < m; i++)
cin >> q[i];
for(int i = 0; i < m; i++) {
auto j = lower_bound(pre.begin(), pre.end(), make_pair(q[i], 0LL));
if(j != pre.end())
cout << j -> second << " ";
else if(sum <= 0)
cout << -1 << " ";
else {
q[i] -= pre.back().first;
ll val = cl(q[i], sum);
q[i] -= val * sum;
ll ans = val * n;
j = lower_bound(pre.begin(), pre.end(), make_pair(q[i] + pre.back().first, 0LL));
ans += j -> second;
cout << ans << " ";
}
}
cout << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
typedef pair<int, int> PII;
typedef pair<LL,LL> PLL;
const int INF = 0x3f3f3f3f, N = 2e5 + 10;
inline int lc(int u) {return u << 1;}
inline int rc(int u) {return u << 1 | 1;}
inline int lowbit(int x) {return x & (-x);}
LL a[N], s[N];
LL mm[N];
struct node {
LL val;
int idx;
bool operator < (const node &B) const {
if (val != B.val) return val < B.val;
return idx < B.idx;
}
} p[N];
inline void solve() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i <= n; i ++ ) mm[i] = -1e9 - 1;
LL ma = -1e9 - 1, mi = 1e9 + 1;
for (int i = 1; i <= n; i ++ ) {
int x;
scanf("%d", &x);
s[i] = s[i - 1] + (LL)x;
ma = max(ma, s[i]);
mi = min(mi, s[i]);
p[i] = {s[i], i};
mm[i] = max(mm[i - 1], s[i]);
}
LL T = s[n];
while (m -- ) {
int x;
scanf("%d", &x);
if (ma < x && T <= 0) printf("-1 ");
else {
if (ma < x) {
LL round = (x - ma + T - 1) / T;
int l = 1, r = n;
while (l < r) {
int mid = (l + r) >> 1;
if (round * T + mm[mid] >= x) r = mid;
else l = mid + 1;
}
printf("%lld ", round * n + l - 1);
} else {
int l = 1, r = n;
while (l < r) {
int mid = (l + r) >> 1;
if (mm[mid] >= x) r = mid;
else l = mid + 1;
}
printf("%d ", l - 1);
}
}
}
puts("");
}
int main() {
// ios::sync_with_stdio(false), cin.tie(nullptr);
int t;
scanf("%d", &t);
while (t -- )
solve();
return 0;
}
|
#pragma GCC optimize("Ofast,no-stack-protector,unroll-loops,fast-math,O3")
#include <bits/stdc++.h>
using namespace std ;
const int inf = 1e9 ;
const int MAX = 2e5 + 10 ;
long long arr[MAX] ;
int val[MAX] , suff[MAX] ;
int n , q ;
vector<long long>v ;
long long sum = 0 ;
void compress()
{
for(int i = 1 ; i <= n ; ++i)
v.push_back(arr[i]) ;
sort(v.begin() , v.end()) ;
v.erase(unique(v.begin() , v.end()) , v.end()) ;
for(int i = 1 ; i <= n ; ++i)
arr[i] = lower_bound(v.begin() , v.end() , arr[i]) - v.begin() + 1 ;
}
void preprocess()
{
for(int i = 1 ; i <= n ; ++i)
arr[i] += arr[i-1] ;
sum = arr[n] ;
compress() ;
for(int i = 1 ; i <= n ; ++i)
val[i] = inf ;
for(int i = 1 ; i <= n ; ++i)
val[arr[i]] = min(val[arr[i]] , i) ;
suff[n] = val[n] ;
for(int i = n-1 ; i >= 1 ; --i)
suff[i] = min(suff[i+1] , val[i]) ;
}
int check(long long a , long long x)
{
long long y = a * sum ;
if(y >= x)
return 0 ;
x -= y ;
if(x > v.back())
return inf ;
int idx = lower_bound(v.begin() , v.end() , x) - v.begin() ;
return suff[idx+1] ;
}
int main()
{
ios_base::sync_with_stdio(0) ;
cin.tie(0) ;
int t ;
cin>>t ;
while(t--)
{
v.clear() ;
cin>>n>>q ;
for(int i = 1 ; i <= n ; ++i)
cin>>arr[i] ;
preprocess() ;
while(q--)
{
int x ;
cin>>x ;
int ans = check(0 , x) ;
if(ans != inf)
cout<<ans-1<<" " ;
else if(sum <= 0)
cout<<-1<<" " ;
else
{
long long l = 1 , r = (x+sum-1) / sum ;
long long ans = r*n ;
while(l <= r)
{
long long mid = (l + r) >> 1ll ;
if(check(mid , x) != inf)
ans = mid , r = mid-1 ;
else
l = mid+1 ;
}
ans = ans * n + check(ans , x) ;
cout<<ans-1<<" " ;
}
}
cout<<"\n" ;
}
return 0 ;
}
|
#include <bits/stdc++.h>
#define IO ios_base::sync_with_stdio(false);\
cin.tie(0);\
cout.tie(0)
using namespace std;
typedef long long ll;
const int N = 2e5 + 10;
int t;
int n, m;
ll a[N], b[N];
ll c[N];
int main()
{
IO;
cin >> t;
while(t --)
{
cin >> n >> m;
for(int i = 1; i <= n; i ++)
{
cin >> a[i];
a[i] += a[i - 1];
c[i] = max(c[i - 1], a[i]);
}
for(int i = 1; i <= m; i ++)
{
cin >> b[i];
if(c[n] >= b[i])
cout<<lower_bound(c + 1, c + n + 1, b[i]) - c - 1<<" ";
else
{
if(a[n] <= 0)
cout<<"-1"<<" ";
else
{
ll sum = (b[i] - c[n] + a[n] - 1) / a[n];
b[i] -= sum * a[n];
sum *= n;
sum += lower_bound(c + 1, c + n + 1, b[i]) - c - 1;
cout<<sum<<" ";
}
}
}
cout<<'\n';
}
return 0;
}
|
#include<bits/stdc++.h>
#define ll long long
using namespace std;
const int maxn=3e5+10;
ll sum[maxn];
ll arr[maxn],xrr[maxn];
ll ans[maxn];
#define PII pair<ll,int>
int main()
{
int T;cin>>T;
while(T--)
{
int n,m;cin>>n>>m;
ll mx=-(1e12);
for(int i=1;i<=n;i++) cin>>arr[i];
for(int i=1;i<=m;i++) cin>>xrr[i];
for(int i=1;i<=n;i++) sum[i]=sum[i-1]+arr[i];
vector<PII> v;v.clear();
for(int i=1;i<=n;i++) if(sum[i]>mx) v.push_back({sum[i],i}),mx=sum[i];
// sort(v.begin(),v.end(),[](PII a,PII b){if(a.first!=b.first) return a.first<b.first;
// else return a.second<b.second;});
vector<ll> lowv;lowv.clear();
for(auto x:v) lowv.push_back(x.first);
for(int i=1;i<=m;i++)
{
ll cur=xrr[i];
int pos=lower_bound(lowv.begin(),lowv.end(),cur)-lowv.begin();
if(pos!=lowv.size())
{
if(lowv[pos]>=cur) ans[i]=v[pos].second-1;
}
else
{
if(sum[n]<=0 ) ans[i]=-1;
else
{
// ll lst=cur-mx;
// ll k=0;
// if(lst%sum[n]==0) k=lst/sum[n];
// else k=lst/sum[n]+1;
ll k=(cur-mx-1)/sum[n]+1;
ll tmp_lst=k*sum[n];
pos=lower_bound(lowv.begin(),lowv.end(),cur-tmp_lst)-lowv.begin();
if(pos!=lowv.size()) ans[i]=v[pos].second-1+k*n;
else ans[i]=-1;
}
}
}
for(int i=1;i<=m;i++) cout<<ans[i]<<" ";
cout<<endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define N 200020
int a[N], x[N], y[N];
long long int s[N];
bool cmp(int i, int j) {
return s[i] < s[j];
}
int main() {
int tc;
scanf("%d", &tc);
for(int cc=0; cc<tc; cc++) {
int n, m;
scanf("%d %d", &n, &m);
for(int i=0; i<n; i++) {
scanf("%d", &a[i]);
x[i] = i;
}
s[0] = a[0];
for(int i=1; i<n; i++) {
s[i] = s[i-1] + a[i];
}
sort(x, x+n, cmp);
y[n-1] = x[n-1];
for(int i=n-2; i>=0; i--) {
y[i] = min(y[i+1], x[i]);
}
for(int i=0; i<m; i++) {
int sum;
scanf("%d", &sum);
if(s[n-1] <= 0 && s[x[n-1]] < sum) {
printf("-1 ");
continue;
}
long long int step = 0;
if(s[n-1] > 0) {
int start = 0, end = ((long long int)sum + sum) / s[n-1], p = -1;
while(start <= end) {
int mid = (start + end) / 2;
if((long long int)mid * s[n-1] + s[x[n-1]] >= sum) {
p = mid;
end = mid - 1;
} else {
start = mid + 1;
}
}
// assert(p != -1);
if(p != -1) {
sum = sum - (p * s[n-1]);
step = step + (long long int)p * n;
}
}
int start = 0, end = n-1, p = -1;
while(start <= end) {
int mid = (start + end) / 2;
if(sum <= s[x[mid]]) {
p = mid;
end = mid - 1;
} else {
start = mid + 1;
}
}
// printf("step before: %d ", step);
assert(p != -1);
step += y[p];
printf("%lld ", step);
}
printf("\n");
}
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
#define Go_ ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0);
#define ll long long int
#define llu long long unsigned int
#define pii pair<int ,int>
#define PII pair<ll ,ll>
const int Max=1e9+100;
const ll MAX=1e18+500;
const ll sz=2e5+100;
map<ll,ll> mp;
int main()
{
Go_
ll a,b,c,i,j,k,q,p,x,y,ct,ct1,m,l,r,x1,y1,mn,h,sum1,in,z,mid,n,mx;
char ch;
double d;
string str1,str2,str;
bool bl,bl1;
int t,cs=1;
cin>>t;
while(t--)
{
cin>>n>>m;
mp.clear();
ll sum=0;
vector<ll> test;
for(ll i=1;i<=n;i++)
{
cin>>x;
sum+=x;
if(mp.count(sum)==0){
test.push_back(sum);
mp[sum]=i-1;
}
}
sort(test.begin(), test.end());
ll siz=test.size();
ll mn[siz];
if(siz>0) mn[siz-1]=mp[test[siz-1]];
for(ll i=siz-2;i>=0;i--){
mn[i]=min(mn[i+1], mp[test[i]]);
}
vector<ll> ans;
for(ll i=1;i<=m;i++)
{
cin>>x;
auto it=lower_bound(test.begin(), test.end(), x);
if(it != test.end()){
ll pos=it-test.begin();
pos=mn[pos];
ans.push_back(pos);
}
else{
if(sum<=0) ans.push_back(-1ll);
else{
ll p=(x/sum);
if(p<0ll) {
ans.push_back(-1ll);
continue;
}
p=((x-test[siz-1]))/sum+((x-test[siz-1])%sum>0ll);
ll le=(p * (n-1))+max(0ll, p-1);
ll rem=(x-(p*sum));
if(rem>0ll){
++le;
ll pos=lower_bound(test.begin(), test.end(), rem)-test.begin();
le+=mn[pos];
}
ans.push_back(le);
}
}
}
for(auto xx: ans) cout<<xx<<" ";
cout<<'\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
///////////////////////////////////*****************//////////////////////////////////////
typedef long long ll;
ll z=1000000007;
ll fact[400005];
void buildfact()
{
fact[0]=1;
for(ll i=1;i<400005;i++)
{
fact[i]=(fact[i-1]*i)%z;
}
}
ll power(ll a,ll p)
{
if(p==0)
return 1;
if(p%2==0)
return power((a*a)%z,p/2);
return (a*power(a,p-1))%z;
}
ll ncr(ll n,ll r)
{
if(n<r)
return 0;
ll num=fact[n];
ll deno=(fact[r]*fact[n-r])%z;
deno=power(deno,z-2);
ll ans=(num*deno)%z;
return ans;
}
//////////////////////////////////////****************//////////////////////////////////////
void solve(int oper)
{
ll n,m;
cin>>n>>m;
ll sum=0;
ll arr[n],queries[m];
for(int i=0;i<n;i++)
{
cin>>arr[i];
sum+=arr[i];
if(i>0)
arr[i]+=arr[i-1];
}
for(int i=0;i<m;i++)
cin>>queries[i];
vector <ll> helper;
vector <ll> ans(m,0);
helper.push_back(arr[0]);
map <int,int> index;
index[0]=0;
for(int i=1;i<n;i++)
{
if(helper[helper.size()-1]<arr[i])
{
helper.push_back(arr[i]);
index[helper.size()-1]=i;
}
}
for(int i=0;i<m;i++)
{
ll x=queries[i];
ll sol=0;
ll lastval=helper[helper.size()-1];
if(x>lastval&&sum<=0)
ans[i]=-1;
else
{
if(x<=lastval)
{
int in=lower_bound(helper.begin(),helper.end(),x)-helper.begin();
ans[i]=index[in];
}
else{
ll times=ceil(float(x-lastval)/sum);
x-=(times*sum);
int in=lower_bound(helper.begin(),helper.end(),x)-helper.begin();
ans[i]=index[in]+times*n;
}
}
}
for(int i=0;i<m;i++)
cout<<ans[i]<<" ";
cout<<endl;
return;
}
int main()
{
ll t;
t=1;
cin>>t;
//buildfact();
int i=1;
while(i<=t)
{
solve(i);
i++;
}
return 0;
}
|
#include <bits/stdc++.h>
using ll = long long;
char df = '\n';
using namespace std;
void solve() {
int n, m;
cin >> n >> m;
ll A[n], ar[n], mx[n];
for (int i = 0; i < n; i++) cin >> A[i];
ar[0] = A[0];
for (int i = 1; i < n; i++) ar[i] = A[i]+ar[i-1];
mx[0] = ar[0];
for (int i = 1; i < n; i++) mx[i] = max(mx[i-1], ar[i]);
while (m--) {
ll x;
cin >> x;
if (x > mx[n-1]) {
if (ar[n-1] <= 0) {
cout << -1 << " ";
} else {
ll y = (x-mx[n-1])/ar[n-1];
if ((x-mx[n-1])%ar[n-1]) y++;
auto it = lower_bound(mx, mx+n, x-y*ar[n-1]);
cout << it-mx+y*n << " ";
}
} else {
auto it = lower_bound(mx, mx+n, x);
cout << it-mx << " ";
}
}
cout << df;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int tt = 1;
cin >> tt;
while (tt--) solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N=2e5+10,M=1e9+7,OO=0x3f3f3f3f;
int n;
int arr[N];
ll pre[N];
ll seg[4*N];
void build(int si=0,int ss=0,int se=n-1){
if(ss==se){
seg[si]=pre[ss];
return;
}
int md=ss+(se-ss)/2,lf=si*2+1,rt=si*2+2;
build(lf,ss,md);
build(rt,md+1,se);
seg[si]=max(seg[lf],seg[rt]);
}
int go_for(ll val,int si=0,int ss=0,int se=n-1){
if(seg[si]<val) return -1;
if(ss==se) return ss;
int md=ss+(se-ss)/2,lf=si*2+1,rt=si*2+2;
if(seg[lf]>=val) return go_for(val,lf,ss,md);
return go_for(val,rt,md+1,se);
}
int main(){
//freopen("haa.txt","r",stdin);
//freopen("myfile.txt","w",stdout);
int t;
scanf("%d",&t);
while(t--){
int m;
scanf("%d%d",&n,&m);
for(int i=0;i<n;++i)
scanf("%d",arr+i);
pre[0]=arr[0];
for(int i=1;i<n;++i)
pre[i]=pre[i-1]+arr[i];
build();
while(m--){
int x;
scanf("%d",&x);
int cur=go_for(x);
if(cur==-1&&pre[n-1]<=0){
printf("-1 ");
continue;
}
else if(cur!=-1){
printf("%d ",cur);
continue;
}
else{
int lo=1,hi=1e9;
while(lo<hi){
int md=lo+(hi-lo)/2;
if(md*1ll*pre[n-1]+seg[0]<x) lo=md+1;
else hi=md;
}
ll cnt=lo*1ll*n+go_for(x-lo*pre[n-1]);
printf("%lld ",cnt);
}
}
puts("");
}
return 0;
}
|
#pragma GCC optimize("O3")
#include <bits/stdc++.h>
using namespace std;
#define forn(i, n) for (int i = 0; i <= (int)n; ++i)
#define forin(i, a, b) for (int i = a; i <= (int)b; ++i)
#define rofin(i, a, b) for (int i = a; i >= b; --i)
#define all(x) (x).begin(), (x).end()
#define sync \
ios::sync_with_stdio(false); \
cin.tie(NULL)
#ifdef LOCAL
#define debug(i) cout << #i << ": " << i << endl
#else
#define debug(i)
#endif
using ll = long long;
using pii = pair<int, int>;
using vb = vector<bool>;
using vi = vector<int>;
using vvi = vector<vi>;
using vll = vector<ll>;
using vvll = vector<vll>;
using pll = pair<ll, ll>;
using vpll = vector<pll>;
const ll inf = 1e17;
void solve() {
int n, m;
cin >> n >> m;
vll a(n + 1);
vpll prefix;
ll sum = 0;
forin(i, 1, n) {
cin >> a[i];
sum += a[i];
if (prefix.empty() || sum > prefix.back().first) {
prefix.emplace_back(sum, i);
}
}
forin(i, 1, m) {
ll x;
cin >> x;
if (prefix.back().first < x && sum <= 0) {
cout << -1 << ' ';
continue;
}
ll rounds = x <= prefix.back().first ? 0 : (x - prefix.back().first + sum - 1) / sum;
x -= rounds * sum;
ll ans = rounds * n;
pll search = { x, 0LL };
auto it = lower_bound(prefix.begin(), prefix.end(), search);
assert(it < prefix.end());
cout << ans + prefix[it - prefix.begin()].second - 1 << ' ';
}
cout << '\n';
}
int main() {
sync;
int t;
cin >> t;
while (t--) solve();
}
|
#include<bits/stdc++.h>
#define IOS ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);cout<<setprecision(25);
#define pb push_back
typedef long long int ll;
ll M=1000000007;
using namespace std;
int main()
{
IOS;
ll T;
cin>>T;
while(T--)
{
ll n,m,i,sum=0;
cin>>n>>m;
ll a[n],mx[n],pref[n];
for(i=0;i<n;i++)
{
cin>>a[i];
sum+=a[i];
}
pref[0]=a[0];
mx[0]=a[0];
for(i=1;i<n;i++){
pref[i]=pref[i-1]+a[i];
mx[i]=max(mx[i-1],pref[i]);
}
for(i=0;i<m;i++)
{
ll q,ans=0;
cin>>q;
if(q>mx[n-1]){
if(pref[n-1]<=0){
cout<<-1<<" ";
continue;
}
else{
ans=(q-mx[n-1]+pref[n-1]-1)/pref[n-1];
q-=ans*pref[n-1];
}
}
ll idx=lower_bound(mx,mx+n,q)-mx;
cout<<(ans*n)+idx<<" ";
}
cout<<endl;
}
}
|
#include<bits/stdc++.h>
using namespace std;
const int N=2e5+200;
typedef long long ll;
ll a[N],b[N];
ll sum[N];
int main()
{
int T;scanf("%d",&T);
while(T--)
{
ll mx=-1e18;memset(sum,0,sizeof sum);
int n,m;scanf("%d%d",&n,&m);
for(int i=1;i<=n;i++)scanf("%lld",&a[i]);
for(int i=1;i<=n;i++){sum[i]=sum[i-1]+a[i],mx=max(mx,sum[i]);}
ll qq=sum[n];
for(int i=1;i<=n;i++){sum[i]=max(sum[i],sum[i-1]);}
while(m--)
{
ll x,w=0;scanf("%lld",&x);
if(x>mx){
if(qq<=0){
printf("-1 ");continue;
}
else {
w=(x-mx+qq-1)/qq;
x-=w*qq;
}
}
int pos=lower_bound(sum+1,sum+n+1,x)-sum;
printf("%lld ",w*n+pos-1);
}
printf("\n");
}
}
|
/*
** Author: Kartikey Tewari
** Time: 02-04-2021 17:40:25
*/
#include <bits/stdc++.h>
#define ll long long
using namespace std;
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(0);
ll tt;
cin >> tt;
for (ll yy=0;yy<=tt-1;yy++)
{
ll n,m;
cin >> n >> m;
vector<ll> arr(n);
ll sum=0;
for (ll i=0;i<=n-1;i++)
{
cin >> arr[i];
sum+=arr[i];
}
vector<ll> query(m);
for (ll i=0;i<=m-1;i++)
{
cin >> query[i];
}
vector<ll> pre_sum(n);
ll val=0;
ll pre_sum_max=0;
for (ll i=0;i<=n-1;i++)
{
val+=arr[i];
pre_sum[i]=val;
pre_sum_max=max(pre_sum_max, pre_sum[i]);
}
vector<ll> pre_inc;
vector<ll> pre_index;
ll lead=pre_sum[0];
pre_inc.push_back(lead);
pre_index.push_back(0);
for (ll i=0;i<=n-1;i++)
{
if (pre_sum[i]>lead)
{
lead=pre_sum[i];
pre_inc.push_back(lead);
pre_index.push_back(i);
}
}
for (ll i=0;i<=m-1;i++)
{
if ((query[i]>pre_sum_max)&&(sum<=0))
{
cout << "-1 ";
}
else
{
ll min_round=0;
if (query[i]>pre_sum_max)
{
min_round=(query[i]-pre_sum_max)/sum;
if (((query[i]-pre_sum_max)%sum)!=0)
{
min_round++;
}
}
ll rem=query[i]-(min_round*sum);
auto it=lower_bound(pre_inc.begin(),pre_inc.end(),rem);
ll dval=distance(pre_inc.begin(),it);
ll ans=n*min_round;
if (dval==(ll)pre_index.size())
{
if (ans==0)
{
ans+=*pre_index.rbegin();
}
else
{
ans+=*pre_index.rbegin()+1;
}
}
else
{
ans+=pre_index[dval];
}
cout << ans << " ";
}
}
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 2e5 + 10;
int n,m;
long long sum;
long long a[N];
vector<pair<long long,int>> v;
int minp[N];
long long solve(long long x){
long long maxv = v[v.size() - 1].first;
if(maxv < x && sum <= 0) return -1;
if(x <= maxv){
int l = 0,r = v.size() - 1;
while(l < r){
int mid = (l + r) / 2;
if(v[mid].first < x) l = mid + 1;
else r = mid;
}
return minp[l] - 1;
}
long long cnt = 0;
if(sum > 0) cnt = (x - maxv) / sum;
x -= sum * cnt;
if(x > maxv){
cnt++;
x -= sum;
}
int l = 0,r = v.size() - 1;
while(l < r){
int mid = (l + r) / 2;
if(v[mid].first < x) l = mid + 1;
else r = mid;
}
return cnt * n + minp[l] - 1;
}
int main(){
int t;scanf("%d",&t);
int Kase = 0;
while(t--){
scanf("%d%d",&n,&m);
sum = 0;
for(int i = 1;i <= n; ++i){
scanf("%lld",a + i);
sum += a[i];
}
v.clear();
long long tmp = 0;
for(int i = 1;i <= n; ++i){
tmp += a[i];
v.push_back({tmp,i});
}
sort(v.begin(),v.end());
minp[v.size()] = n + 1;
for(int i = v.size() - 1;i >= 0 ;--i){
minp[i] = min(minp[i + 1],v[i].second);
}
// for(int i = 0;i < v.size(); ++i) cout << minp[i] << " ";
// cout << endl;
for(int i = 0;i < m; ++i){
long long x;scanf("%lld",&x);
printf("%lld ",solve(x));
}
//printf("case: %d",++Kase);
puts("");
}
return 0;
}
|
/// vonat1us
#pragma GCC optimize("O3")
//#pragma comment(linker, "/STACK:36777216")
#include<bits/stdc++.h>
#define x first
#define y second
#define pb push_back
#define sz(x) (int) x.size()
#define all(z) (z).begin(), (z).end()
using namespace std;
using ll = long long;
using pii = pair<int, int>;
const int MOD = 1e9 + 7;
const int INF = 1e9 + 1e2;
//mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
void fin() {
#ifdef AM
freopen(".in", "r", stdin);
#endif
}
const bool flag = 1;
const int N = 2e5+10;
ll n, p[N], t[N<<2];
void build(int u = 0, int l = 0, int r = n+1) {
if (r-l == 1) {
t[u] = p[l];
return;
}
int m = l+r >> 1;
build(u+u+1, l, m);
build(u+u+2, m, r);
t[u] = max(t[u+u+1], t[u+u+2]);
}
int get(ll x, int u = 0, int l = 0, int r = n+1) {
if (t[u] < x) {
return -1;
}
if (r-l == 1) {
return l;
}
int m = l+r >> 1;
if (t[u+u+1] >= x) {
return get(x, u+u+1, l, m);
} else {
return get(x, u+u+2, m, r);
}
}
void ma1n() {
int q;
cin >> n >> q;
for (int i = 0; i < n; ++i) {
cin >> p[i+1], p[i+1] += p[i];
}
build();
ll s = p[n];
ll mx = *max_element(p, p+n+1);
for (ll x; q--;) {
cin >> x;
ll ans = -1;
if (s <= 0) {
ans = get(x);
} else {
ll l = 0;
ll r = 1e9;
while (l <= r) {
ll m = l+r >> 1ll;
if (m > x/s) {
ans = m*n, r = m-1;
continue;
}
int pos = get(x-m*s);
if (~pos) {
ans = m*n + pos, r = m-1;
} else {
l = m+1;
}
}
}
cout << (~ans ? ans-1 : -1) << " ";
}
cout << "\n";
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(nullptr), fin();
int ts = 1;
if (flag) {
cin >> ts;
}
while (ts--) {
ma1n();
}
return 0;
}
|
#include <bits/stdc++.h>
#define ll long long
#define IOS ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
#define deb(x) cout<<#x<<"="<<x<<endl;
#define endl '\n'
#define M 1000000007
#define int long long
#define INF 1e18
#define N 1000005
using namespace std;
void solve()
{
ll n, m;
cin >> n >> m;
ll a[n];
ll sum = 0;
set<pair<ll, ll>> s;
ll pre[n];
for (int i = 0; i < n; ++i)
{
cin >> a[i];
sum += a[i];
}
ll mx = 0;
for (int i = 0; i < n; ++i)
{
if (i == 0)pre[i] = a[i];
else pre[i] = pre[i - 1] + a[i];
if (pre[i] > mx)
s.insert({pre[i], i});
mx = max(mx, pre[i]);
}
while (m--)
{
ll x;
cin >> x;
if (x <= mx)
{
ll pos = s.lower_bound({x, -1})->second;
cout << pos << " ";
}
else if (sum <= 0)
{
cout << -1 << " ";
}
else
{
ll round = (x - mx) / sum;
if (x - round * sum > mx)
round++;
x -= round * sum;
ll pos = s.lower_bound({x, -1})->second;
cout << pos + round*n << " ";
}
} cout << endl;
}
int32_t main()
{
IOS
ll T = 1;
cin >> T;
for (ll i = 1; i <= T; ++i)
{
// cout<<"Case #"<<i<<": ";
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template<class TH> void _dbg(const char *sdbg, TH h){ cerr<<sdbg<<'='<<h<<endl; }
template<class TH, class... TA> void _dbg(const char *sdbg, TH h, TA... a) {
while(*sdbg!=',')cerr<<*sdbg++;
cerr<<'='<<h<<','; _dbg(sdbg+1, a...);
}
template<class T> ostream &operator<<(ostream& os, vector<T> V) {
os << "["; for (auto vv : V) os << vv << ","; return os << "]";
}
template<class L, class R> ostream &operator<<(ostream &os, pair<L,R> P) {
return os << "(" << P.first << "," << P.second << ")";
}
#ifdef LOCAL
#define debug(...) _dbg(#__VA_ARGS__, __VA_ARGS__)
#else
#define debug(...) 42
#endif
using ll = long long;
using ld = long double;
using uint = unsigned int;
using ull = unsigned long long;
template<typename T>
using pair2 = pair<T, T>;
using pii = pair<int, int>;
using pli = pair<ll, int>;
using pll = pair<ll, ll>;
using vi = vector<int>;
using vii = vector<pii>;
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
#define sz(x) (int)(x).size()
#define mp make_pair
#define pb push_back
#define fi first
#define se second
#define lb lower_bound
#define ub upper_bound
#define all(x) x.begin(), x.end()
#define re(n) for (int i = 0; i < n; ++i)
#define rep(i,a,b) for (int i = a; i < b; ++i)
#define eb emplace_back
//OutPut
void ps(ll x) {
cout << x << endl;
}
void ps(char x) {
cout << x << endl;
}
void ps(string x) {
cout << x << endl;
}
void ps(vi a) {
for (int i = 0; i < a.size(); ++i) {
if (i) cout << " ";
cout << a[i];
}
cout << endl;
}
void ps(vector<ll> a) {
for (int i = 0; i < a.size(); ++i) {
if (i) cout << " ";
cout << a[i];
}
cout << endl;
}
#define ps_end(x) {ps(x); return;}
const int md = 1e9 + 7; //998244353 ;
const int dir[4][2] = {{-1,0}, {1, 0}, {0, -1}, {0, 1}};
template<class T> bool ckmin(T& a, const T& b) {
return b < a ? a = b, 1 : 0; }
template<class T> bool ckmax(T& a, const T& b) {
return a < b ? a = b, 1 : 0; }
void setIO(string s){
ios_base::sync_with_stdio(false);
cin.tie(0);
freopen((s+".in").c_str(),"r",stdin);
freopen((s+".out").c_str(),"w",stdout);
}
const int maxn = 1e6 + 10;
int n, m, nq, nk;
string str;
void task() {
cin >> n; cin >> m;
vi a(n);
re(n) cin >> a[i];
ll init = a[0];
vector<ll> sum(n + 1);
re(n) sum[i + 1] = sum[i] + a[i];
vector<pair<ll, int>> p;
ll last = -1e18;
re(n) {
if (sum[i + 1] > last) {
p.pb({sum[i + 1], i});
last = sum[i + 1];
}
}
assert(p.size() >= 1);
debug(p);
vector<ll> ans(m);
for (int i = 0; i < m; ++i) {
ll x; cin >> x;
if (p.back().fi < x && sum[n] <= 0) {
ans[i] = -1;
continue;
}
ll diff = x - p.back().fi;
ll T = 0;
if (diff > 0 && sum[n] > 0) T = (diff - 1) / sum[n] + 1;
x -= sum[n] * T;
auto it = lower_bound(p.begin(), p.end(), make_pair(x, -1));
assert(it != p.end());
ans[i] = T * n + it->se;
}
ps(ans);
//Read the stuff at the bottom
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout<<fixed<<setprecision(20);
int T = 1;
cin >> T;
for (int ti = 1; ti <= T; ++ti) {
task();
}
return 0;
}
/* stuff you should look for
* int overflow, array bounds
* special cases (n=1?)
* do smth instead of nothing and stay organized
* write down
*/
|
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define pii pair<int, int>
#define pll pair<long long, long long>
#define pb push_back
#define ff first
#define ss second
#define YES cout << "YES\n"
#define NO cout << "NO\n"
#define nn "\n"
#define sci(x) scanf("%d", &x)
#define LL_INF (1LL << 62)
#define INF (1 << 30)
#define SetBit(x, k) (x |= (1LL << k))
#define ClearBit(x, k) (x &= ~(1LL << k))
#define CheckBit(x, k) (x & (1LL << k))
#define mod 1000000007
#define N 200005
int arr[N];
int tree[4*N];
void init(int b, int e, int node = 1)
{
if (b == e)
{
tree[node] = arr[b];
return;
}
int left = node * 2;
int right = node * 2 + 1;
int mid = (b + e) / 2;
init(b, mid, left);
init(mid + 1, e, right);
tree[node] = min(tree[left], tree[right]);
}
int query(int b, int e, int i, int j, int node = 1)
{
if (b >= i && e <= j)
return tree[node];
if (b > j || e < i)
return (INF);
int left = node * 2;
int right = node * 2 + 1;
int mid = (b + e) / 2;
return min(query(b, mid, i, j, left), query(mid + 1, e, i, j, right));
}
int main()
{
ios::sync_with_stdio(false);
cin.tie(nullptr);
int t;
cin >> t;
while(t--){
int n, m;
cin >> n >> m;
memset(arr, 0, sizeof(arr[0])*(n+3));
for(int i = 0; i < 4*n+3; i++){
tree[i] = INF;
}
ll x[n];
for(int i = 0; i < n; i++){
cin >> x[i];
if(i>0) x[i] += x[i-1];
}
vector<pll> v;
for(int i = 0; i < n; i++){
v.pb({x[i], i});
}
sort(v.begin(), v.end());
vector<ll> val, indx;
for(int i = 0; i < n; i++){
val.pb(v[i].ff);
indx.pb(v[i].ss);
arr[i+1] = v[i].ss;
}
init(1, n);
ll sum = x[n-1];
for(int i = 0; i < m; i++){
int x;
cin >> x;
if(val.back() >= x){
int p = lower_bound(val.begin(), val.end(), x) - val.begin();
int z = query(1, n, p+1, n);
cout << z << " ";
}
else {
if(sum <= 0) cout << -1 << " ";
else {
ll rem = x-val.back();
ll cnt = rem/sum;
if(rem%sum) cnt++;
ll ans = LL_INF;
ll need = x-cnt*sum;
// cout << need << ":" << val.back() << "***" << nn;
if(val.back() >= need){
int p = lower_bound(val.begin(), val.end(), need) - val.begin();
int z = query(1, n, p+1, n);
ans = cnt*n+z;
}
need = x-(cnt-1)*sum;
if(val.back() >= need){
int p = lower_bound(val.begin(), val.end(), need) - val.begin();
int z = query(1, n, p+1, n);
ans = min(ans, (cnt-1)*n+z);
}
cout << ans << " ";
}
}
}
cout << nn;
}
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
#define ll long long int
#define pb push_back
#define mp make_pair
#define all(x) x.begin(), x.end()
#define fr first
#define sc second
#define pii pair<ll,ll>
#define vi vector<ll>
#define vvi vector<vector<ll>>
#define rep(i,a,b) for(ll i=a;i<b;i++)
// const ll mod = 1000000007;
const ll mod = 998244353;
ll z = 1000000000;
#define PI 3.14159265
int gcd(int a, int b)
{
if (!a)
return b;
return gcd(b % a, a);
}
ll powe(ll x, ll y)
{
if (y == 0) return 1;
if (y == 1) return x;
ll t = powe(x, y / 2);
t = (t * t) % mod;
if (y % 2 == 1) t = (t * x) % mod;
return t;
}
ll binomialCoeff(ll n, ll k)
{
ll C[n + 1][k + 1];
ll i, j;
for (i = 0; i <= n; i++)
{
for (j = 0; j <= min(i, k); j++)
{
if (j == 0 || j == i)
C[i][j] = 1;
else
C[i][j] = C[i - 1][j - 1] +
C[i - 1][j];
}
}
return C[n][k];
}
// bool checkSubset(vi &nums, int sum)
// {
// vector<vector<bool>> dp(nums.size()+1, vector<bool> (sum+1));
// for(int i=0;i<=nums.size();i++)
// dp[i][0] = true;
// for(int i=0;i<= sums;i++)
// dp[0][i] = false;
// for(int i=1;i<=nums.size();i++)
// {
// for(int j=1;j<=sums;j++)
// {
// if(j<nums[i-1])
// dp[i][j] = dp[i-1][j];
// else
// dp[i][j] = dp[i-1][j] || dp[i-1][j - nums[i-1]];
// }
// }
// return dp[nums.size()][sum];
// }
vi primeFactors(ll n)
{
// Print the number of 2s that divide n
vi res;
while (n % 2 == 0)
{
res.pb(2);
n = n / 2;
}
// n must be odd at this point. So we can skip
// one element (Note i = i +2)
for (int i = 3; i <= sqrt(n); i = i + 2)
{
// While i divides n, print i and divide n
while (n % i == 0)
{
res.pb(i);
n = n / i;
}
}
// This condition is to handle the case when n
// is a prime number greater than 2
if (n > 2)
return {n};
return res;
}
void precal()
{
int invFact[400005], fact[400005], intermediate[400005];
invFact[1] = invFact[0] = 1;
fact[1] = fact[0] = 1;
intermediate[1] = intermediate[0] = 1;
rep(i, 2, 200001)
{
intermediate[i] = intermediate[mod % i] * (mod - mod / i) % mod;
}
rep(i, 2, 200001)
{
fact[i] = (fact[i - 1] * i) % mod;
invFact[i] = (intermediate[i] * invFact[i - 1]) % mod;
}
}
// ll dfs(vector<int> &x, vector<bool> &vis, int i)
// {
// ll len = 1;
// while (x[i] != 0)
// {
// if (vis[x[i]] == 1)
// return len + 1;
// vis[x[i]] = 1;
// i = x[i];
// len++;
// }
// return len;
// }
int dfs(vector<vector<int>> &graph, int u, vector<vector<int>> &reducedGraph)
{
if (graph[u].size() == 0)
return u;
if (graph[u].size() == 1)
{
int child = dfs(graph, graph[u][0], reducedGraph);
reducedGraph[u].pb(child);
return child;
}
for (int i = 0; i < graph[u].size(); i++)
{
int child = dfs(graph, graph[u][i], reducedGraph);
reducedGraph[u].pb(child);
}
return u;
}
ll calc(vector<vector<int>> &reducedGraph, int u, int w, map<pair<int, int>, int> &mp)
{
if (mp.find({u, w}) != mp.end())
return mp[ {u, w}];
int childs = reducedGraph[u].size();
if ( childs == 0)
return 0;
if (w % childs != 0)
return w;
ll val = 0;
for (int i = 0; i < reducedGraph[u].size(); i++)
{
val += calc(reducedGraph, reducedGraph[u][i], w / childs, mp);
}
return mp[ {u, w}] = val;
}
vector<bool> SieveOfEratosthenes(int n)
{
vector<bool> prime(n + 1, true);
for (int p = 2; p * p <= n; p++)
{
if (prime[p] == true)
{
for (int i = p * p; i <= n; i += p)
prime[i] = false;
}
}
prime[1] = false;
return prime;
}
int count(int a, int b)
{
int c = 0;
while (a * 2 < b)
{
a = a * 2;
c++;
}
return c;
}
int main()
{
ios_base::sync_with_stdio(0);
cin.tie(0);
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
int test = 1;
cin >> test;
while (test--)
{
ll n, m;
cin >> n >> m;
vector<ll> a(n), sum(n, 0);
ll maxa = INT_MIN;
rep(i, 0, n)
{
cin >> a[i];
}
sum[0] = a[0];
maxa = max(maxa, a[0]);
rep(i, 1, n)
{
sum[i] += (sum[i - 1] + a[i]);
maxa = max(maxa, sum[i]);
}
vector<ll> pref;
pref.pb(sum[0]);
ll pre = sum[0];
map<ll, ll> mp;
mp[sum[0]] = 0;
rep(i, 1, n)
{
if (sum[i] > pre)
{
pref.pb(sum[i]);
pre = sum[i];
mp[sum[i]] = i;
}
}
while (m--)
{
ll x;
cin >> x;
ll ans = 0;
if (x > maxa && sum[n - 1] <= 0)
cout << "-1 ";
else
{
if (x > maxa)
{
ll z = (x - maxa) / sum[n - 1];
while ((z * sum[n - 1]) + maxa < x)
z++;
x = x - (z * sum[n - 1]);
ans += (z * n);
// cout << "hi";
}
ll ind = (lower_bound(all(pref), x) - pref.begin());
cout << ans + mp[pref[ind]] << " ";
}
}
cout << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef vector<vi> vvi;
typedef vector<vll> vvll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<pii> vpii;
typedef vector<pll> vpll;
typedef vector<vpii> vvpii;
typedef vector<vpll> vvpll;
#define pb push_back
#define mp make_pair
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define sz(x) (int)(x).size()
#define fi first
#define se second
template<class T> bool ckmin(T &a, const T &b) {return a > b ? a = b, 1 : 0;}
template<class T> bool ckmax(T &a, const T &b) {return a < b ? a = b, 1 : 0;}
void __print(int x) {cerr << x;}
void __print(long long x) {cerr << x;}
void __print(double x) {cerr << x;}
void __print(long double x) {cerr << x;}
void __print(char x) {cerr << '\'' << x << '\'';}
void __print(const string &x) {cerr << '\"' << x << '\"';}
void __print(bool x) {cerr << (x ? "true" : "false");}
template<typename T, typename V>
void __print(const pair<T, V> &x) {cerr << '{'; __print(x.first); cerr << ','; __print(x.second); cerr << '}';}
template<typename T>
void __print(const T &x) {int f = 0; cerr << '{'; for(auto z : x) cerr << (f++ ? "," : ""), __print(z); cerr << "}";}
void _print() {cerr << "]\n";}
template <typename T, typename... V>
void _print(T t, V... v) {__print(t); if(sizeof...(v)) cerr << ", "; _print(v...);}
#ifdef ljuba
#define dbg(x...) cerr << "LINE(" << __LINE__ << ") -> " << "[" << #x << "] = ["; _print(x)
#else
#define dbg(x...)
#endif
const char nl = '\n';
void solve() {
int n, m;
cin >> n >> m;
vll v(n);
for(auto &z : v)
cin >> z;
vi x(m);
for(auto &z : x)
cin >> z;
ll pref = 0;
ll maksi = 0;
vll prefMax(n);
for(int i = 0; i < n; ++i) {
pref += v[i];
ckmax(maksi, pref);
prefMax[i] = maksi;
}
ll sve = pref;
//dbg(prefMax);
for(int i = 0; i < m; ++i) {
if(sve <= 0) {
if(x[i] > prefMax.back())
cout << -1 << " ";
else {
cout << upper_bound(all(prefMax), x[i]-1) - prefMax.begin() << " ";
}
} else {
ll krug = max(0LL, (x[i] - prefMax.back() + sve - 1) / sve);
ll ans = krug * n;
//dbg(krug);
ans += upper_bound(all(prefMax), x[i] - krug*sve - 1) - prefMax.begin();
cout << ans << " ";
}
}
cout << nl;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int testCases = 1;
cin >> testCases;
while(testCases--)
solve();
}
|
#include <bits/stdc++.h>
#define watch(x) cout <<(#x)<<" is "<<(x)<<endl
#define debug cout <<"hi"<<endl
#define maxn 3e5+10
#define inf32 0x3f3f3f3f
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
typedef pair<ll, ll> pll;
typedef pair<int,int>pii;
const int MOD=1e9+7;
const int INF32=1<<30;
const ll INF64=1LL<<60;
void solve(){
int tc;cin >> tc;
while(tc--){
ll n,m;cin >> n >> m;
vector<ll>a(n),x(m);
for(int i = 0;i<n;i++) cin >> a[i];
for(int i = 0;i<m;i++) cin >> x[i];
vector<ll>pre(n+1,0);
for(int i = 1;i<=n;i++) pre[i] = pre[i-1]+a[i-1];
ll cycle = pre[n];
for(int i = 1;i<=n;i++) pre[i] = max(pre[i],pre[i-1]);
for(int i = 0;i<m;i++){
if(cycle<=0&&pre[n]<x[i]){
cout << -1 <<' ';continue;
}
ll l = 1,check = 0;ll r = 0;
if(cycle<=0) r = n-1;
else if(pre[n]>=1e9) r = n;
else r = 2e18/cycle+10;
while(l<=r){
ll mid = (l+r)/2;
ll check = (mid/n)*cycle+pre[mid%n];
if(mid>=n) check = max(check,(mid/n-1)*cycle+pre[n]);
if(check>=x[i]) r = mid-1;
else l = mid+1;
}
cout << l-1 <<' ';
}
cout <<'\n';
}
}
int main(){
ios_base::sync_with_stdio(0);
cin.tie(0); cout.tie(0);
solve();
return 0;
}
|
/*
*
* Author: Hsueh-
* Date: 2021-03-05 21:34:52
*
* */
#include <bits/stdc++.h>
using namespace std;
#define dbg(x...) \
do { \
cout << #x << " -> "; \
err(x); \
} while (0)
void err() { cout << endl; }
template <class T, class... Ts> void err(const T &arg, const Ts &...args) {
cout << arg << " ";
err(args...);
}
#define endl "\n"
#define all(A) A.begin(), A.end()
using ll = long long;
using db = double;
using pII = pair<int, int>;
const int INF = 0x3f3f3f3f;
const ll INFLL = 0x3f3f3f3f3f3f3f3f;
const int N = 2e5 + 10;
int n, m;
int a[N];
void RUN() {
cin >> n >> m;
map<ll, int> mp;
ll sum = 0, Max = 0;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
sum += a[i];
if (sum > Max) {
Max = sum;
mp[sum] = i;
}
}
for (int i = 1; i <= m; ++i) {
ll x;
cin >> x;
auto it = mp.lower_bound(x);
ll res = 0;
if (it == mp.end() && sum <= 0) {
res = -1;
} else if (it == mp.end()) {
auto last = mp.end();
last--;
ll need = (x - last->first + sum - 1) / sum;
it = mp.lower_bound(x - need * sum);
res = it->second + need * n - 1;
} else {
res = it->second - 1;
}
cout << res << " \n"[i == m];
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr), cout.tie(nullptr);
cout << fixed << setprecision(20);
int T;
cin >> T;
while (T--) {
RUN();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int lim=1e6;int inf=1e8;
ll mod = 1e9+7;
#define ln '\n'
#define forstl(it,v) for(auto &it: v)
#define fi first
#define se second
#define dbg(args...) { string _s = #args; replace(_s.begin(), _s.end(), ',', ' '); \
stringstream _ss(_s); istream_iterator<string> _it(_ss); err(_it, args); }
void err(istream_iterator<string> it) { cerr<<endl; }
template<typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {
cerr << *it << " = " << a << "\t"; err(++it, args...);
}
template<typename T1,typename T2>
ostream& operator <<(ostream& c,pair<T1,T2> v){
c<<"("<<v.fi<<","<<v.se<<")"; return c;
}
template <template <class...> class TT, class ...T>
ostream& operator<<(ostream& out,TT<T...>& c){
out<<"{ ";
forstl(x,c) out<<x<<" ";
out<<"}"; return out;
}
int main()
{
// ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);
int t; cin>>t;
while(t--){
int n, m; cin>>n>>m;
int a[n];
for(int i=0;i<n;i++) cin>>a[i];
int x[m];
for(int i=0;i<m;i++) cin>>x[i];
pair<ll, int> cum[n];
cum[0] = make_pair(a[0], 0);
for(int i=1;i<n;i++) cum[i] = make_pair(cum[i-1].first+a[i], i);
ll loopsum = cum[n-1].first;
int endzeros = 0;
for(int i=n-1;i>=0;i--){
if(a[i]==0) endzeros++;
else break;
}
sort(cum, cum+n);
int minind[n];
minind[n-1] = cum[n-1].second;
for(int i = n-2;i>=0;i--){
minind[i] = min(minind[i+1], cum[i].second);
}
for(int i=0;i<m;i++){
if(x[i] > cum[n-1].first){
if(loopsum <= 0) cout<<-1<<" ";
else{
ll q = ceil((x[i]-cum[n-1].first)/((double)loopsum));
ll rem = x[i] - loopsum*q;
int ind = lower_bound(cum, cum+n, make_pair(rem, -1)) - cum;
ll ans = q*n + minind[ind];
cout<<ans<<" ";
}
}else{
int ind = lower_bound(cum, cum+n, make_pair((ll)x[i], -1)) - cum;
cout<<minind[ind]<<" ";
}
}
cout<<ln;
}
}
|
//**sn0wrus**//
#include <bits/stdc++.h>
#include <algorithm>
using namespace std;
#define fast \
ios_base::sync_with_stdio(false); \
cout.tie(NULL); \
cin.tie(NULL);
#define write(a) \
for (auto x : a) \
{ \
cout << x << " "; \
} \
cout << endl;
#define read(a) \
for (auto &x : a) \
{ \
cin >> x; \
}
#define IN cin >>
#define OUT cout <<
//#define endl "\n"
#define all(a) (a).begin(), (a).end()
#define allr(a) (a).rbegin(), (a).rend()
#define pb push_back
#define fi first;
#define se second;
using ll = long long int;
using ld = long double;
using pll = pair<ll, ll>;
using pii = pair<int, int>;
using plll = pair<ll,pll>;
using vll = vector<ll>;
using vi = vector<int>;
const ll mod = (ll)(1e9) + 7LL;
const ll M = 998244353LL;
const int dir8[8][2]={{1,0},{0,1},{-1,0},{0,-1},{1,1},{1,-1},{-1,1},{-1,-1}};
const int dir4[4][2]={{1,0},{0,1},{-1,0},{0,-1}};
/*
for(int i=0;i<n-1;i++)
{
int a,b;
cin>>a>>b;
a--,b--;
adj[a].push_back(b);
adj[b].push_back(a);
}
*/
bool comp(pll a,pll b)
{
if(a.first < b.first)
{
return true;
}
else if(a.first==b.first)
{
if(a.second < b.second)
{
return true;
}
}
return false;
}
ll fun (vector<pll>&pre, ll x)
{
ll n =pre.size();
ll l=0,r=n;
while(l<r)
{
ll mid = l+(r-l)/2;
if(pre[mid].first < x)
{
l=mid+1;
}
else{
r=mid;
}
}
return pre[l].second;
}
void solve()
{
ll n,m;
cin>>n>>m;
vector<ll>arr(n);
vector<ll>arr1(m);
for(int i=0;i<n;i++)cin>>arr[i];
for(int i=0;i<m;i++)cin>>arr1[i];
vector<pll>pre(n);
vector<pll>tmp;
ll mx=arr[0];
for(int i=0;i<n;i++)
{
if(i==0)
{
pre[i].first=arr[i];
}
else{
pre[i].first=pre[i-1].first+arr[i];
}
pre[i].second=i;
mx = max(mx,pre[i].first);
if(pre[i].first < mx)
{
}
else{
tmp.push_back(pre[i]);
}
}
ll sum = pre[n-1].first;
sort(all(pre),comp);
// for(auto i:pre)
// {
// cout<<i.first<<" ";
// }
// cout<<endl;
for(int i=0;i<m;i++)
{
ll ans;
// cout<<i<<endl;
ll x = arr1[i];
// cout<<"x"<<x<<endl;
ll last = x - mx;
// cout<<"last"<<last<<endl;
if(last <= 0)
{
ans=0;
}
else{
if(sum <= 0)
{
cout<<-1<<" ";
continue;
}
ans = (last+sum-1)/sum;
}
// cout<<"ans"<<ans<<endl;
ll curr = sum*ans;
// cout<<"curr"<<curr<<endl;
ans *=n;
ll t = x-curr;
// cout<<"t"<<t<<endl;
ll qq = fun(tmp,t);
// cout<<"qq"<<qq<<endl;
ans+=qq;
cout<<ans<<" ";
}
cout<<endl;
return;
}
int main()
{
fast;
ll tc = 1;
IN tc;
while (tc--)
{
solve();
}
return 0;
}
|
#include<iostream>
#include<cstdio>
#include<cstring>
#include<string>
#include<vector>
#include<cmath>
#include<algorithm>
#include<map>
#include<queue>
#include<deque>
#include<iomanip>
#include<tuple>
#include<cassert>
#include<set>
#include<complex>
#include<numeric>
#include<functional>
#include<unordered_map>
#include<unordered_set>
using namespace std;
typedef long long int LL;
typedef pair<LL,LL> P;
typedef pair<LL,int> LP;
const int INF=1<<30;
const LL MAX=1e9+7;
void array_show(int *array,int array_n,char middle=' '){
for(int i=0;i<array_n;i++)printf("%d%c",array[i],(i!=array_n-1?middle:'\n'));
}
void array_show(LL *array,int array_n,char middle=' '){
for(int i=0;i<array_n;i++)printf("%lld%c",array[i],(i!=array_n-1?middle:'\n'));
}
void array_show(vector<int> &vec_s,int vec_n=-1,char middle=' '){
if(vec_n==-1)vec_n=vec_s.size();
for(int i=0;i<vec_n;i++)printf("%d%c",vec_s[i],(i!=vec_n-1?middle:'\n'));
}
void array_show(vector<LL> &vec_s,int vec_n=-1,char middle=' '){
if(vec_n==-1)vec_n=vec_s.size();
for(int i=0;i<vec_n;i++)printf("%lld%c",vec_s[i],(i!=vec_n-1?middle:'\n'));
}
namespace sol{
void init(){
}
void solve(){
int n,m;
int i,j,k;
LL a,b,c;
LL x,y;
vector<LL> v1,vs;
vector<P> va;
cin>>n>>m;
b=0;
va.push_back(make_pair(0,-1));
for(i=0;i<n;i++){
cin>>a;
v1.push_back(a);
b+=a;
if(va.back().first<b)va.push_back(make_pair(b,i));
}
for(i=0;i<m;i++){
cin>>a;
LL s=-1;
auto itr=lower_bound(va.begin(),va.end(),make_pair(a,-2LL));
if(itr==va.end()){
if(b<=0){
vs.push_back(-1);
continue;
}
x=(a-va.back().first-1)/b+1;
s+=x*n,a-=x*b;
if(a<=0){
vs.push_back(s);
continue;
}
itr=lower_bound(va.begin(),va.end(),make_pair(a,-2LL));
}
assert(itr!=va.end());
s+=itr->second+1;
vs.push_back(s);
}
for(i=0;i<m;i++){
if(i)cout<<" ";
cout<<vs[i];
}
cout<<endl;
}
}
int main(){
int n,i;
sol::init();
cin.tie(0);
ios::sync_with_stdio(false);
cin>>n;
for(i=0;i<n;i++){
sol::solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int inf=2e9;
const int maxn=2e5+10;
int t,n,m;
ll tot;
ll a[maxn],sum[maxn];
ll tw[maxn];
int main()
{
ios::sync_with_stdio(false);cin.tie(0);
cin>>t;
while (t--)
{
cin>>n>>m;tot=0;tw[0]=-inf;
for (int i=1;i<=n;i++)
{
cin>>a[i];
tot+=a[i];
sum[i]=sum[i-1]+a[i];
tw[i]=max(tw[i-1],sum[i]);
}
for (int i=1;i<=m;i++)
{
int x;cin>>x;
if (tw[n]<x && sum[n]<=0) {cout<<-1<<' ';continue;}
ll res=0;
if (x<=tw[n]) res+=lower_bound(tw+1,tw+n+1,x)-tw;
else
{
res=(x-tw[n]+sum[n]-1)/sum[n];x-=res*sum[n];
res*=n;
res+=lower_bound(tw+1,tw+n+1,x)-tw;
}
cout<<res-1<<' ';
}
cout<<endl;
for (int i=1;i<=n;i++) a[i]=sum[i]=tw[i]=0;
}
return 0;
}
|
#include <iostream>
#include <vector>
using namespace std;
class MergeSortTree {
private:
int n;
vector<vector<long long> > t;
inline int left(int i) {return i << 1;}
inline int right(int i) {return (i << 1) + 1;}
void merge(int idx) {
const vector<long long> &a = t[left(idx)];
const vector<long long> &b = t[right(idx)];
vector<long long> &merge_arr = t[idx];
merge_arr.resize(a.size() + b.size());
int ia = 0, ib = 0, i = 0;
while(ia < a.size() || ib < b.size()) {
if(ib == b.size()) merge_arr[i ++] = a[ia ++];
else if(ia == a.size()) merge_arr[i ++] = b[ib ++];
else {
if(a[ia] <= b[ib]) merge_arr[i ++] = a[ia ++];
else merge_arr[i ++] = b[ib ++];
}
}
}
void build_tree(const vector<long long> &a, int low, int high, int idx) {
if(low == high) {
t[idx].push_back(a[low]);
return;
}
int mid = (low + high) >> 1;
build_tree(a, low, mid, left(idx));
build_tree(a, mid + 1, high, right(idx));
merge(idx);
}
int get_leftmost_geq_idx(long long x, int low, int high, int idx) {
if(low == high) {
if(t[idx][0] >= x) return low;
else return -1;
}
int mid = (low + high) >> 1;
if(t[left(idx)].back() >= x)
return get_leftmost_geq_idx(x, low, mid, left(idx));
else
return get_leftmost_geq_idx(x, mid + 1, high, right(idx));
}
public:
MergeSortTree(const vector<long long> &a):
n(a.size()), t(4 * n) {build_tree(a, 0, n - 1, 1);}
inline int get_leftmost_geq_idx(long long x) {
return get_leftmost_geq_idx(x, 0, n - 1, 1);
}
};
inline void enable_fast_io() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
}
void read_input(vector<long long> &prefix_sum, int &m) {
int n;
cin >> n >> m;
prefix_sum.resize(n);
cin >> prefix_sum[0];
for(int i = 1;i < n;i++) {
int x;
cin >> x;
prefix_sum[i] = prefix_sum[i - 1] + x;
}
}
inline long long ceil_div(long long a, long long b) {
return (a + b - 1) / b;
}
void solve_queries(const vector<long long> &prefix_sum, int &m) {
int n = prefix_sum.size();
MergeSortTree merge_sort_tree(prefix_sum);
long long max_prefix_sum = prefix_sum[0];
for(int i = 1;i < n;i++)
max_prefix_sum = max(max_prefix_sum, prefix_sum[i]);
long long total_sum = prefix_sum.back();
while(m --) {
long long x;
cin >> x;
long long num_seconds;
if(total_sum <= 0 || x <= max_prefix_sum || x < 0)
num_seconds = merge_sort_tree.get_leftmost_geq_idx(x);
else {
long long num_times = ceil_div(x - max_prefix_sum, total_sum);
x -= num_times * total_sum;
num_seconds = num_times * n + merge_sort_tree.get_leftmost_geq_idx(x);
}
printf("%lld ", num_seconds);
}
printf("\n");
}
int main() {
enable_fast_io();
int t;
cin >> t;
while(t --) {
vector<long long> prefix_sum;
int m;
read_input(prefix_sum, m);
solve_queries(prefix_sum, m);
}
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
#define LL long long
const int N = 200010;
int n, m;
LL a[N], s[N];
//
int cnt;
LL val[N];
int id[N];
//
LL ans[N];
void solve()
{
//printf("one Test\n");
//input
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++i)
scanf("%lld", &a[i]), s[i] = s[i - 1] + a[i];
//pre
cnt = 0;
for (int i = 1; i <= n; ++i)
if (s[i] > val[cnt])
id[++cnt] = i, val[cnt] = s[i];
//debug1
/*
printf("cnt=%d\nval : ", cnt);
for (int i = 1; i <= cnt; ++i)
printf("%lld ", val[i]);
printf("\n");
*/
//solve
for (int i = 1; i <= m; ++i) {
ans[i] = -1;
LL x;
scanf("%lld", &x);
if (cnt == 0) continue;
if (x <= val[cnt]) {
int k = lower_bound(val + 1, val + cnt + 1, x) - val;
ans[i] += id[k];
continue;
}
if (s[n] <= 0) continue;
LL tmp = (x - val[cnt] + s[n] - 1) / s[n];
ans[i] += n * tmp, x -= s[n] * tmp;
//while (x > val[cnt]) ans[i] += n, x -= s[n];
int k = lower_bound(val + 1, val + cnt + 1, x) - val;
ans[i] += id[k];
}
//output
//printf("ans:");
for (int i = 1; i < m; ++i)
printf("%lld ", ans[i]);
printf("%lld\n", ans[m]);
}
int main()
{
int T;
scanf("%d", &T);
while (T--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
#include <unordered_map>
//Author: Maximilian Paris
using namespace std;
typedef long long ll;
vector<pair<ll, ll>> prefix_sorted;
ll compare = 1e18;
struct sort_pred {
bool operator()(const std::pair<int, int>& left, const std::pair<int, int>& right) {
return left.second < right.second;
}
};
int main() {
int t; cin >> t;
while (t--) {
ll ans = 0;
int n, m;
cin >> n >> m;
prefix_sorted = vector<pair<ll, ll>>(n);
vector<ll> prefix(n) ;
ll max_sum = 0;
for (int i = 0; i < n; i++) {
ll x;
cin >> x;
if (i > 0)
prefix_sorted[i] = { x + prefix_sorted[i - 1].first,i}, prefix[i]= prefix_sorted[i].first;
else prefix_sorted[i] = {x,i }, prefix[i] = prefix_sorted[i].first;
max_sum = max(max_sum, prefix_sorted[i].first);
}
vector<ll> X(m);
for (int i = 0; i < m; i++)cin >> X[i];
int size_arr = n;
ll max_prefix = prefix_sorted[n - 1].first;
sort(prefix_sorted.begin(), prefix_sorted.end());
unordered_map<ll, ll> pos;
int j = 0;
for (int i = 0; i < n; i++) {
while (true) {
if (pos[prefix_sorted[i].first] == 0 && prefix_sorted[i].first <= prefix[j])
{
pos[prefix_sorted[i].first] = j + 1; break;
}
else if(prefix_sorted[i].first > prefix[j])j++;
else { break; }
}
}
for (int i = 0; i < m; i++) {
if (X[i] > max_sum && max_prefix <= 0)
cout << -1 << " ";
else if (X[i] <= max_sum) {
// int to = 0;
pair<ll, ll> b = { X[i],0};
int to=lower_bound(prefix_sorted.begin(), prefix_sorted.end(), b)- prefix_sorted.begin();
// for (int j = to; j < n; j++)ans = min(ans, prefix_sorted[j].second);
cout << pos[prefix_sorted[to].first]-1 << " ";
}
else {
ll cnt= (ll(ceil((double(X[i] - max_sum)) / double(max_prefix))));
ll check = X[i] - cnt* max_prefix; pair<ll, ll> b = {check,0 };
int k = lower_bound(prefix_sorted.begin(), prefix_sorted.end(), b) - prefix_sorted.begin();
//for (int j = k; j < n; j++)val = min(val, prefix_sorted[j].second);
ll ans = pos[prefix_sorted[k].first]-1 +cnt* size_arr;
// for (int j = 0; j < n; j++) {
// ans = min(ans, (ll(ceil((double(X[i] - prefix[j]))/double(max_prefix))))* size_arr +j);
// }
cout << ans<< " ";
}
}
cout << endl;
}
return 0x0;
}
|
#include<bits/stdc++.h>
#define read(arr, n) vector<int> arr(n); for(int i=0; i<n; i++) cin>>arr[i];
#define fastio ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#define fr(i, m, n) for(int i=m;i<n;i++)
#define frr(i, a, b) for(int i=a; i>b; i--)
#define w(tt) int tt; cin>>tt; while(tt--)
#define w1(tt) if(true)
#define vi(ty) vector<ty>
#define vvi(ty) vector<vector<ty>>
#define umap(ty) unordered_map<ty, ty>
#define umapp(ty, tyy) unordered_map<ty, tyy>
#define pii pair<int, int>
#define ll long long int
#define yes cout<<"YES"<<endl
#define no cout<<"NO"<<endl
#define len(x) x.size()
#define pb push_back
#define F first
#define S second
#define I insert
#define mod 1000000007
using namespace std;
void file(){
#ifndef ONTLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
}
void solve() // return 1 -> it did it's purpose properly.
{
ll n, q, cnt = 0, maxi = INT_MIN, prev = -1; cin>>n>>q;
map<ll, ll> hash;
fr(i, 0, n)
{
ll x; cin>>x; cnt += x;
if(cnt >= 0 && cnt > prev)
{hash[cnt] = i; prev = cnt;}
}
maxi = prev;
ll query[q];
fr(i, 0, q) cin>>query[i];
fr(i, 0, q)
{
ll x = query[i];
auto it = hash.lower_bound(x);
if(it != hash.end())
{
//cout << "&";
cout << it->S <<" ";
}
else if( it == hash.end() && cnt > 0)
{
ll temp = x - maxi;
ll t = ceil(temp/(cnt*1.0));
temp = x - t*cnt;
it = hash.lower_bound(temp);
//if(it==hash.end())
// cout<<"^"<<it->S<<"^";
cout << it->S + t*n << " ";
}
else
{cout<<-1<<" ";}
}
cout<<endl;
}
int main(){
fastio //file();
w(tt){
solve();
}
}
// -1 -1
// 1 1
|
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
const int inf=1000000000;
int g[300000],q[300000],w[300000];
long long h[300000],v[300000];
int i,k,m,n,o,t,l,r,mid;
long long M;
inline bool cmp(int x,int y)
{
return q[x]<q[y];
}
int main()
{
scanf("%d",&t);
for (o=1;o<=t;o++)
{
scanf("%d%d",&n,&m);
for (i=1;i<=n;i++)
scanf("%d",&g[i]),h[i]=h[i-1]+g[i];
M=g[1];
for (i=1;i<=n;i++)
M=max(M,h[i]);
for (i=1;i<=m;i++)
scanf("%d",&q[i]),w[i]=i;
memset(v,0,sizeof(v));
if (h[n]>0)
for (i=1;i<=m;i++)
if (q[i]>M)
{
l=1,r=inf;
while (l<r)
{
mid=(l+r)/2;
if (q[i]-1LL*mid*h[n]<=M)
r=mid;
else
l=mid+1;
}
q[i]=q[i]-1LL*l*h[n];
v[i]=v[i]+1LL*l*n;
}
sort(w+1,w+m+1,cmp);
for (i=1,k=1;i<=m;i++)
if (q[w[i]]<=M)
{
while (h[k]<q[w[i]])
k++;
v[w[i]]=v[w[i]]+k-1;
}
else
v[w[i]]=-1;
for (i=1;i<=m;i++)
printf("%lld ",v[i]);
printf("\n");
}
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define M 1000000007
int main()
{
int t; scanf("%d",&t);
while(t--)
{
int n,m; scanf("%d %d",&n,&m);
ll a[n]; for(int i=0;i<n;i++) scanf("%lld",&a[i]);
int b[m]; for(int i=0;i<m;i++) scanf("%d",&b[i]);
vector<ll>v;
vector<int>v1;
ll sum=a[0]; v.push_back(a[0]); v1.push_back(1);
ll prev=a[0]; ll y=a[0];
for(int i=1;i<n;i++){
sum+=a[i];
if(i==n-1) y=sum;
if(sum>prev){
v.push_back(sum);
v1.push_back(i+1);
prev=sum;
}
}
ll maxx=v[v.size()-1];
for(int i=0;i<m;i++)
{
if(b[i]<=maxx)
{
int c=lower_bound(v.begin(),v.end(),b[i])-v.begin();
printf("%d ",v1[c]-1);
}
else if(y>0){
int x=b[i]-((b[i]-maxx+y-1)/y)*y;
int c=lower_bound(v.begin(),v.end(),x)-v.begin();
ll ans=((b[i]-maxx+y-1)/y)*n+v1[c]-1;
printf("%lld ",ans);
}
else printf("-1 ");
}
printf("\n");
}
}
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
#define int ll
#define lp3(i,s,n) for(int i = s;i < int(n); ++i)
#define lp(i, n) lp3(i,0,n)
#define pb push_back
#define debug(x) cout<<"[" << #x << " is: " << x << "] "<<endl;
#define file freopen("input.in","r",stdin);
#define fastIO std::ios::sync_with_stdio(false); cin.tie(0);
#define x first
#define y second
void solve(){
int n, m;
cin>>n>>m;
int all = 0;
vector<int> v(n);
vector<pair<int, int>> up;
lp(i, n){
cin>>v[i];
all+=v[i];
if(all > 0 && (up.empty() || all>up.back().x))
up.push_back({all, i});
}
while(m--){
//debug(m)
int k; cin>>k;
if(up.empty() || k > up.back().x && all <= 0)
cout<<-1<<" ";
else{
int ans = 0;
if(all > 0 && k > up.back().x ){
int z = (k-up.back().x+all-1)/all;
k -= z*all;
ans = z * n;
}
if(k == 0){
cout<<ans-1<<" ";
continue;
}
int lo = 0, hi = int(up.size())-1;
int best = 0;
while(lo <= hi){
int md = lo + (hi - lo)/2;
if(up[md].x >= k){
hi = md-1;
best = up[md].y;
}
else{
lo = md+1;
}
}
cout<<best+ans<<" ";
}
}
cout<<endl;
}
int32_t main() { fastIO
int t; cin>>t;
while(t--){
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string to_string(char x) {
string re;
re += '\'';
re += x;
re += '\'';
return re;
}
template <typename A, typename B>
string to_string(pair<A, B> p);
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p);
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p);
string to_string(const string& s) {
return '"' + s + '"';
}
string to_string(const char* s) {
return to_string((string)s);
}
string to_string(bool b) {
return (b ? "true" : "false");
}
string to_string(vector<bool> v) {
bool first = true;
string res = "{";
for (int i = 0; i < static_cast<int>(v.size()); i++) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(v[i]);
}
res += "}";
return res;
}
template <size_t N>
string to_string(bitset<N> v) {
string res = "";
for (size_t i = 0; i < N; i++) {
res += static_cast<char>('0' + v[i]);
}
return res;
}
template <typename A>
string to_string(A v) {
bool first = true;
string res = "{";
for (const auto& x : v) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(x);
}
res += "}";
return res;
}
template <typename A, typename B>
string to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " +
to_string(get<2>(p)) + ")";
}
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " +
to_string(get<2>(p)) + ", " + to_string(get<3>(p)) + ")";
}
void debug_out() {
cerr << endl;
}
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
cerr << " " << to_string(H);
debug_out(T...);
}
#define LOCAL
//#undef LOCAL
#ifdef LOCAL
#define debug(...) cerr << "[" << #__VA_ARGS__ << "]:", debug_out(__VA_ARGS__)
#else
#define debug(...)
#endif
#define fi first
#define se second
#define ins insert
#define pb push_back
#define em emplace
#define eb emplace_back
#define sz(x) ((int)x.size())
#define all(x) x.begin(), x.end()
#define IOS \
ios::sync_with_stdio(0); \
cin.tie(0)
#define fk(i, a, b) for (int i = (a); i < (b); ++i)
#define fb(i, a, b) for (int i = (a); i <= (b); ++i)
#define fan(i, a, b) for (int i = (a); i >= (b); --i)
#define foreach(i, x) for (auto& i : x)
#define frei freopen("i", "r", stdin)
#define freo freopen("o", "w", stdout)
using namespace std;
using i32 = int;
using ll = long long;
using i64 = long long;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using vi = vector<int>;
using vl = vector<ll>;
using si = set<int>;
using sl = set<ll>;
using mii = map<int, int>;
using mll = map<ll, ll>;
template <typename T>
using S = set<T>;
template <typename T>
using V = vector<T>;
template <typename T>
using Q = queue<T>;
template <typename T>
using DQ = deque<T>;
template <typename T>
using ST = stack<T>;
template <typename T, typename _T>
using M = map<T, _T>;
template <typename T>
using DP = priority_queue<T, vector<T>, less<T>>;
template <typename T>
using XP = priority_queue<T, vector<T>, greater<T>>;
const char end1 = '\n';
template <typename T>
ll Min(T a) {
return (ll)a;
}
template <typename Head, typename... Tail>
ll Min(Head H, Tail... T) {
return min((ll)H, Min(T...));
}
template <typename T>
ll Max(T a) {
return (ll)a;
}
template <typename Head, typename... Tail>
ll Max(Head H, Tail... T) {
return max((ll)H, Max(T...));
}
template <typename T>
ll Gcd(T a) {
return a;
}
template <typename Head, typename... Tail>
ll Gcd(Head H, Tail... T) {
return __gcd((ll)H, Gcd(T...));
}
int main() {
IOS;
int t;
cin >> t;
while (t--) {
ll n, m;
cin >> n >> m;
vl v(n + 1);
fb (i, 1, n) {
cin >> v[i];
}
vl sum(n + 1, 0);
vl mx(n + 1, 0);
fb (i, 1, n) {
sum[i] = sum[i - 1] + v[i];
if (i == 1) mx[i] = sum[i];
else mx[i] = max(mx[i - 1], sum[i]);
}
vl ans;
while (m--) {
ll x;
cin >> x;
auto re = lower_bound(all(mx), x);
if (re == mx.end()) {
if (sum.back() <= 0) {
ans.pb(-1);
}
else {
ll sheng = x - mx.back();
ll lun = sheng / sum.back();
if (sheng % sum.back()) ++lun;
sheng = x - lun * sum.back();
auto re2 = lower_bound(all(mx), sheng);
ans.pb(lun * n + (long long )(re2 - mx.begin() - 1));
}
}
else {
ans.pb(re - mx.begin() - 1);
}
}
foreach (i, ans) {
cout << i << ' ';
}
cout << end1;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef pair<ll, ll> pll;
const int Max = 2e6 + 10;
const int Mod = 1e9 + 7;
const ll Inf = 1LL << 62;
ll ar[Max];
ll pos[Max];
ll x[Max];
void Solve() {
ll n, m;
cin >> n >> m;
ll sum = 0, mx = -Inf;
for (ll i = 1; i <= n; i++) {
cin >> ar[i];
sum += ar[i];
mx = max(mx, sum);
pos[i] = mx;
}
for (ll i = 1; i <= m; i++) {
cin >> x[i];
}
for (ll i = 1; i <= m; i++) {
if (x[i] <= mx) {
ll l = 1, r = n, ans = -1;
while (l <= r) {
ll mid = (l + r) >> 1;
if (pos[mid] >= x[i]) {
ans = mid - 1;
r = mid - 1;
} else {
l = mid + 1;
}
}
cout << ans << " ";
} else if(sum <= 0) {
cout << "-1" << " ";
} else {
ll res = Inf;
ll mm = x[i];
mm -= mx;
ll now = mm / sum;
for (ll j = now - 1; j <= now + 1; j++) {
if(j < 1) {
continue;
}
ll now = j * n - 1;
ll l = 1, r = n, ans = -1;
while (l <= r) {
ll mid = (l + r) >> 1;
if (pos[mid] + j * sum >= x[i]) {
ans = mid;
r = mid - 1;
} else {
l = mid + 1;
}
}
if (ans != -1) {
res = min(res, now + ans);
}
}
now = x[i] / sum;
for (ll j = now - 1; j <= now + 1; j++) {
if(j < 1) {
continue;
}
ll now = j * n - 1;
ll l = 1, r = n, ans = -1;
while (l <= r) {
ll mid = (l + r) >> 1;
if (pos[mid] + j * sum >= x[i]) {
ans = mid;
r = mid - 1;
} else {
l = mid + 1;
}
}
if (ans != -1) {
res = min(res, now + ans);
}
}
if (res == Inf) {
res = -1;
}
cout << res << " ";
}
}
cout << endl;
}
int main(int argc, char const *argv[]) {
ios_base::sync_with_stdio();
cin.tie(0);
int T = 1;
cin >> T;
while (T--) {
Solve();
}
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.