#include <bits/stdc++.h>

using namespace std;

typedef long long ll;

const int MAX = 1e5;

int tree[MAX*4];

int query(int s, int e, int node, int rank) {

if (s == e) return s;

int m = (s+e)/2;

if (tree[node*2] >= rank) return query(s, m, node*2, rank);

else return query(m+1, e, node*2+1, rank-tree[node*2]);

}

void update(int s, int e, int node, int index, int diff) {

if (e < index || index < s) return;

tree[node] += diff;

if (s == e) return;

int m = (s+e)/2;

update(s, m, node*2, index, diff);

update(m+1, e, node*2+1, index, diff);

}

void solve(){

int N,K; cin >> N >> K;

for (int i = 1; i <= N; i++) update(1, N, 1, i, 1);

int step = 1;

for (int i = 1; i <= N; i++) {

step = (step + (K-1)) % (N-i+1);

if (step == 0) step = N-i+1;

int result = query(1, N, 1, step);

cout << result;

update(1, N, 1, result, -1);

if (i < N) cout << ", ";

}

}

int main()

{

cin.tie(0)->sync_with_stdio(false);

cout << '<';

solve();

cout << '>';

return 0;

}

#include <bits/stdc++.h>

using namespace std;

typedef long long ll;

const int MAX = 1e6;

int tree[MAX*4];

int query(int s, int e, int node, int rank) {

if (s == e) return s;

int m = (s+e)/2;

if (tree[node*2] >= rank) return query(s, m, node*2, rank);

else return query(m+1, e, node*2+1, rank-tree[node*2]);

}

void update(int s, int e, int node, int index, int diff) {

if (e < index || index < s) return;

tree[node] += diff;

if (s == e) return;

int m = (s+e)/2;

update(s, m, node*2, index, diff);

update(m+1, e, node*2+1, index, diff);

}

void solve(){

int N; cin >> N;

for (int i = 0; i < N; i++) {

int a; cin >> a;

if (a != 1) {

int b,c; cin >> b>>c;

update(1,MAX,1,b,c);

} else {

int b; cin >> b;

int result = query(1, MAX, 1, b);

cout << result << '\n';

update(1,MAX,1,result,-1);

}

}

}

int main()

{

cin.tie(0)->sync_with_stdio(false);

solve();

return 0;

}

#include <bits/stdc++.h>

using namespace std;

typedef long long ll;

const int MAX = 2e6;

int tree[MAX*4];

int query(int s, int e, int node, int rank) {

if (s == e) return s;

int m = (s+e)/2;

if (tree[node*2] >= rank) return query(s, m, node*2, rank);

else return query(m+1, e, node*2+1, rank-tree[node*2]);

}

void update(int s, int e, int node, int index, int diff) {

if (e < index || index < s) return;

tree[node] += diff;

if (s == e) return;

int m = (s+e)/2;

update(s, m, node*2, index, diff);

update(m+1, e, node*2+1, index, diff);

}

void solve(){

int N; cin >> N;

for (int i = 0; i < N; i++) {

int a,b;cin >> a>>b;

if (a == 1) {

update(1,MAX,1,b,1);

} else {

int result = query(1, MAX, 1, b);

cout << result << '\n';

update(1,MAX,1,result,-1);

}

}

}

int main()

{

cin.tie(0)->sync_with_stdio(false);

solve();

return 0;

}

#include <bits/stdc++.h>

using namespace std;

typedef long long ll;

struct Node {

int x;

ll weight;

};

struct Edge {

int v,w,idx;

};

struct Compare {

bool operator()(const Node &a, const Node &b) {

return a.weight > b.weight;

}

};

void solve(){

int N, M; cin >> N >> M;N++;

assert(N>1);

assert(M>1);

int S=1,E=N-1;

vector<vector<Edge>> edges(N);

for (int i = 0; i <M;i++) {

int u,v,w; cin >> u >> v >> w;

edges[u].push_back({v,w,i});

edges[v].push_back({u,w,i});

}

vector<vector<pair<int,int>>> parntes(N);

priority_queue<Node, vector<Node>, Compare> q; q.push({S,0});

ll distances[N]; memset(distances, -1, sizeof(distances)); distances[S]=0;

vector<vector<int>> results;

while (q.size()) {

auto [x, weight] = q.top(); q.pop();

for (auto [nx, w, idx] : edges[x]) {

if (distances[nx] > weight + w) parntes[nx].clear();

if (distances[nx] == -1 || distances[nx] > weight + w) {

parntes[nx].push_back({x,idx});

distances[nx] = weight + w;

q.push({nx, distances[nx]});

}

}

}

bool blocked[M];

memset(blocked, 0, sizeof(blocked));

queue<int> q2; q2.push(E);

while (q2.size()) {

auto p = q2.front(); q2.pop();

for (auto [x, idx] : parntes[p]) {

blocked[idx] = true;

q2.push(x);

}

}

memset(distances, -1, sizeof(distances));

distances[S]=0;

q.push({S,0});

while(q.size()) {

auto [x, weight] = q.top(); q.pop();

for (auto [nx, w, idx] : edges[x]) {

if (blocked[idx]) continue;

if (distances[nx] == -1 || distances[nx] > weight+w) {

distances[nx] = weight+w;

q.push({nx, distances[nx]});

}

}

}

cout << distances[E];

}

int main() {

cin.tie(0) -> sync_with_stdio(0);

solve();

return 0;

}

#include <bits/stdc++.h>

using namespace std;

typedef long long ll;

struct Edge {

int v,w;

};

const ll MOD = 1e9+7;

const int MAX = 1e5;

vector<vector<Edge>> edges(MAX+1);

ll result;

ll dfs(int n, int p) {

ll data = 1;

for (auto [v,w] : edges[n]) {

if (v == p) continue;

ll sub = (dfs(v, n) * w) % MOD;

result = (result + data * sub) % MOD;

data = (data + sub) % MOD;

}

return data;

}

void solve(){

int N; cin >> N;

for (int i = 0; i < N-1; i++) {

int u,v,w;cin>>u>>v>>w;

edges[u].push_back({v,w});

edges[v].push_back({u,w});

}

dfs(1, 0);

cout << result;

}

int main()

{

cin.tie(0)->sync_with_stdio(false);

solve();

return 0;

}

#include <bits/stdc++.h>

using namespace std;

typedef long long ll;

void solve(){

int N; cin >> N;

int arr[1001];

for (int i = 0; i <= 1000; i++) arr[i] = 0;

int max_height = 0;

int max_index = 0;

for (int i = 0; i < N; i++) {

int a, b; cin >> a >> b;

arr[a]=b;

if (max_height < b) {

max_height = b;

max_index = a;

}

}

stack<pair<int,int>> st;

for (int i = 1; i < max_index; i++) {

if (!arr[i]) continue;

int height=arr[i];

if (st.empty() || st.top().second < height) st.push({i, height});

}

int result = max_height;

int r = max_index;

while (st.size()) {

auto [x,y] = st.top(); st.pop();

result += (r-x)*y;

r = x;

}

st.push({max_index, max_height});

for (int i = max_index+1; i <= 1000; i++) {

if (!arr[i]) continue;

int height = arr[i];

while (st.size() && st.top().second < height) st.pop();

st.push({i, height});

}

auto [x,y] = st.top(); st.pop();

while (st.size()) {

auto [ax,ay] = st.top(); st.pop();

result += (x-ax)*y;

x=ax;y=ay;

}

cout << result;

}

int main()

{

cin.tie(0)->sync_with_stdio(false);

solve();

return 0;

}

#include <bits/stdc++.h>

using namespace std;

typedef long long ll;

void solve(){

int N; cin >> N;

deque<int> dq;

int v[N+1];

for (int i = 1; i <= N; i++) {

cin >> v[i];

dq.push_back(i);

}

for (int i = 0; i < N; i++) {

int x = dq.front();

int y = v[x];

cout << x << ' ';

dq.pop_front();

if (y > 0) {

y--;

while ((y--)>0) {

dq.push_back(dq.front());

dq.pop_front();

}

} else {

while (y++) {

dq.push_front(dq.back());

dq.pop_back();

}

}

}

}

int main()

{

cin.tie(0)->sync_with_stdio(false);

solve();

return 0;

}