NOIP2017 D2T3 列队

最新推荐文章于 2020-11-26 19:06:10 发布
最新推荐文章于 2020-11-26 19:06:10 发布
阅读量1.2k 收藏
点赞数
分类专栏： NOIP解题报告 树状数组 线段树 平衡树 文章标签： NOIP 数据结构 平衡树 线段树 树状数组
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/scar_lyw/article/details/78840487
版权

列队

题目背景：

NOIP2017 D2T3

分析：平衡树 or 线段树 or 树状数组

 

考场上因为自己不会实现，所以没有过掉这道题，拿了80的暴力，50分的暴力，和30分的平衡树，50分因为询问次数较少，可以直接提取出对应影响到的行，和最后一列，然后直接暴力维护即可，然后对于30分的只询问第一行，相当于，只会影响到第一行和最后一列，直接将两者接到一起，用平衡树暴力维护删除中间一个数，放到最后就可以了。

 

Source：

/*
	created by scarlyw
*/
#include <cstdio>
#include <string>
#include <cstring>
#include <algorithm>
#include <cctype>
#include <cmath>
#include <iostream>
#include <queue>
#include <set>
#include <vector>

inline char read() {
	static const int IN_LEN = 1024 * 1024;
	static char buf[IN_LEN], *s, *t;
	if (s == t) {
		t = (s = buf) + fread(buf, 1, IN_LEN, stdin);
		if (s == t) return -1;
	}
	return *s++;
}

template<class T>
inline void R(T &x) {
	static char c;
	static bool iosig;
	for (c = read(), iosig = false; !isdigit(c); c = read()) {
		if (c == -1) return ;
		if (c == '-') iosig = true;
	}
	for (x = 0; isdigit(c); c = read())
		x = ((x << 2) + x << 1) + (c ^ '0');
	if (iosig) x = -x;
}

const int OUT_LEN = 1024 * 1024;
char obuf[OUT_LEN], *oh = obuf;
inline void write_char(char c) {
	if (oh == obuf + OUT_LEN) fwrite(obuf, 1, OUT_LEN, stdout), oh = obuf;
	*oh++ = c;
}

template<class T>
inline void W(T x) {
	static int buf[30], cnt;
	if (x == 0) write_char('0');
	else {
		if (x < 0) write_char('-'), x = -x;
		for (cnt = 0; x; x /= 10) buf[++cnt] = x % 10 + 48;
		while (cnt) write_char(buf[cnt--]);
	}
}

inline void flush() {
	fwrite(obuf, 1, oh - obuf, stdout);
}

const int MAXQ = 300000 + 10;

int n, m, q, x, y;
struct data {
	int x, y;
} query[MAXQ];

inline void solve_small() {
	static const int MAXQ = 500 + 10;
	static const int MAXN = 50000 + 10;
	static long long pos[MAXQ][MAXN], last[MAXN];
	static int xx[MAXQ], h[MAXN];
	for (int i = 1; i <= q; ++i) 
		R(query[i].x), R(query[i].y), xx[i] = query[i].x;
	std::sort(xx + 1, xx + q + 1);
	int cnt = 1;
	for (int i = 2; i <= q; ++i) if (xx[i] != xx[i - 1]) xx[++cnt] = xx[i];
	for (int i = 1; i <= cnt; ++i) h[xx[i]] = i;
	for (int i = 1; i <= cnt; ++i)
		for (int j = 1; j < m; ++j)
			pos[i][j] = (long long)(xx[i] - 1) * m + j;
	for (int i = 1; i <= n; ++i) last[i] = (long long)i * m;
	for (int i = 1; i <= q; ++i) {
		int x = query[i].x, y = query[i].y, hh = h[x];
		long long zz;
		if (y != m) zz = pos[hh][y];
		else zz = last[x];
		W(zz), write_char('\n');
		if (y != m) {
			for (int j = y; j < m - 1; ++j) pos[hh][j] = pos[hh][j + 1];
			pos[hh][m - 1] = last[x];
		}
		for (int j = x; j < n; ++j) last[j] = last[j + 1];
		last[n] = zz;
	}
}

struct node *null;
struct node {
	node *lc, *rc;
	long long val;
	int rank, size;
	
	node(long long val = 0) : val(val), rank(rand()), size(1) {
		lc = rc = null;
	}
	
	inline void maintain() {
		size = lc->size + rc->size + 1;
	}
} pool[MAXQ << 1], *root;

int pool_top;

inline node *new_node(long long val = 0) {
	node *u = &pool[pool_top++];
	return *u = node(val), u;
}

inline node *build(long long *a, int n) {
	static node *stack[MAXQ << 1], *pre, *u;
	int top = 0;
	for (int i = 1; i <= n; ++i) {
		u = new_node(a[i]), pre = null;
		while (top && stack[top]->rank > u->rank) 
			pre = stack[top], stack[top]->maintain(), stack[top--] = null;
		if (top) stack[top]->rc = u;
		u->lc = pre, stack[++top] = u;
	}
	while (top) stack[top--]->maintain();
	return stack[1];
}

inline void dfs(node *cur) {
	if (cur->lc != null) dfs(cur->lc);
	std::cout << cur->val << " ";
	if (cur->rc != null) dfs(cur->rc);
}

struct pair {
	node *first, *second;
	pair(node *first, node *second) : first(first), second(second) {}
	pair() {} 
} ;

inline pair split(node *u, int k) {
	if (u == null) return pair(null, null);
	pair t;
	if (k <= u->lc->size) t = split(u->lc, k), u->lc = t.second, t.second = u;
	else t = split(u->rc, k - u->lc->size - 1), u->rc = t.first, t.first = u;
	return u->maintain(), t;
}

inline node *merge(node *u, node *v) {
	if (u == null) return v;
	if (v == null) return u;
	if (u->rank < v->rank) {
		u->rc = merge(u->rc, v);
		return u->maintain(), u;
	}
	else {
		v->lc = merge(u, v->lc);
		return v->maintain(), v;
	}
}

inline void modify(int pos) {
	pair t1 = split(root, pos - 1), t2 = split(t1.second, 1);
	W(t2.first->val), write_char('\n');
	root = merge(t1.first, merge(t2.second, t2.first));	
}

long long a[MAXQ << 1];
inline void solve_special() {
	for (int i = 1; i <= m - 1; ++i) a[i] = i;
	for (int i = 1; i <= n; ++i) a[m - 1 + i] = (long long)i * m;
	null = new_node(0), null->size = 0, null->lc = null->rc = null;
	root = build(a, n + m - 1);
	for (int i = 1; i <= q; ++i) R(x), R(y), modify(y);
}

int main() {
	freopen("phalanx.in", "r", stdin);
	freopen("phalanx.out", "w", stdout);

	R(n), R(m), R(q);
	if (q <= 500) solve_small();
	else solve_special();
	flush();
	return 0;
}

然后，来讲解下题解，首先，平衡树做法可能是最显然的，直接维护n + 1棵平衡树，n棵表示各行，最后一棵表示最后一列，平衡树的节点都不用开满，如果对于一行，询问了中间的某个位置x，我们可以直接将它拆成[l, x - 1], [x + 1, r],[x, x]三个节点，然后合并前两个，将最后一个放到最后一列，并且从最后一列中，提取出对应位置的元素放入这一行的平衡树最后就可以了。最终的节点数不会唱过q * 4 + m，所以直接开5倍MAXN节点个数动态分配就可以了。时间复杂度O(nlogn)，空间复杂度O(n)

Source：

/*
    created by scarlyw
*/
#include <cstdio>
#include <string>
#include <algorithm>
#include <cstring>
#include <iostream>
#include <cmath>
#include <cctype>
#include <vector>
#include <set>
#include <queue>

inline char read() {
    static const int IN_LEN = 1024 * 1024;
    static char buf[IN_LEN], *s, *t;
    if (s == t) {
        t = (s = buf) + fread(buf, 1, IN_LEN, stdin);
        if (s == t) return -1;
    }
    return *s++;
}

///*
template<class T>
inline void R(T &x) {
    static char c;
    static bool iosig;
    for (c = read(), iosig = false; !isdigit(c); c = read()) {
        if (c == -1) return ;
        if (c == '-') iosig = true;	
    }
    for (x = 0; isdigit(c); c = read()) 
        x = ((x << 2) + x << 1) + (c ^ '0');
    if (iosig) x = -x;
}
//*/

const int OUT_LEN = 1024 * 1024;
char obuf[OUT_LEN], *oh = obuf;
inline void write_char(char c) {
    if (oh == obuf + OUT_LEN) fwrite(obuf, 1, OUT_LEN, stdout), oh = obuf;
    *oh++ = c;
}


template<class T>
inline void W(T x) {
    static int buf[30], cnt;
    if (x == 0) write_char('0');
    else {
        if (x < 0) write_char('-'), x = -x;
        for (cnt = 0; x; x /= 10) buf[++cnt] = x % 10 + 48;
        while (cnt) write_char(buf[cnt--]);
    }
}

inline void flush() {
    fwrite(obuf, 1, oh - obuf, stdout);
}

/*
template<class T>
inline void R(T &x) {
    static char c;
    static bool iosig;
    for (c = getchar(), iosig = false; !isdigit(c); c = getchar())
        if (c == '-') iosig = true;	
    for (x = 0; isdigit(c); c = getchar()) 
        x = ((x << 2) + x << 1) + (c ^ '0');
    if (iosig) x = -x;
}
//*/

const int MAXN = 300000 + 10;

struct node *null;
struct node {
    node *lc, *rc;
    int size, rank;
    long long l, r;
    
    node() {}
    node(long long l, long long r) : l(l), r(r), size(r - l + 1), rank(rand()) {
        lc = rc = null;
    }
    
    inline void maintain() {
        size = lc->size + rc->size + r - l + 1;
    }
} pool[MAXN * 5], *root[MAXN], *last;

int pool_top;

inline node* new_node(long long l, long long r) {
    if (r - l + 1 == 0) return null;
    node *u = &pool[pool_top++];
    return *u = node(l, r), u;
}

inline node *build(long long *a, int n) {
    static node *stack[MAXN], *u, *pre;
    int top = 0;
    for (int i = 1; i <= n; ++i) {
        u = new_node(a[i], a[i]), pre = null;
        while (top && stack[top]->rank > u->rank) 
            pre = stack[top], stack[top]->maintain(), stack[top--] = null;
        if (top) stack[top]->rc = u;
        u->lc = pre, stack[++top] = u;
    }
    while (top) stack[top--]->maintain();
    return stack[1];
}

node* merge(node *u, node *v) {
    if (u == null) return v;
    if (v == null) return u;
    if (u->rank < v->rank) {
        u->rc = merge(u->rc, v);
        return u->maintain(), u;
    } else {
        v->lc = merge(u, v->lc);
        return v->maintain(), v;
    }
}

struct pair {
    node *first, *second;
    pair() {} 
    pair(node *first, node *second) : first(first), second(second) {}
} ;

pair split_lower(node *u, int k) {
    if (u == null) return pair(null, null);
    pair t;
    if (k < u->lc->size + u->r - u->l + 1) 
        t = split_lower(u->lc, k), u->lc = t.second, t.second = u;
    else t = split_lower(u->rc, k - u->lc->size - u->r + u->l - 1), 
        u->rc = t.first, t.first = u;
    return u->maintain(), t;
}

pair split_upper(node *u, int k) {
    if (u == null) return pair(null, null);
    pair t;
    if (k <= u->lc->size) 
        t = split_upper(u->lc, k), u->lc = t.second, t.second = u;
    else t = split_upper(u->rc, k - u->lc->size - u->r + u->l - 1), 
        u->rc = t.first, t.first = u;
    return u->maintain(), t;
}

int n, m, q, x, y;
long long a[MAXN];

inline void solve() {
    null = &pool[pool_top++], null->lc = null->rc = null;
    null->l = null->r = null->size = 0, null->rank = rand();
    R(n), R(m), R(q);
    for (int i = 1; i <= n; ++i) a[i] = (long long)m * i;
    last = build(a, n);
    for (int i = 1; i <= n; ++i) 
        root[i] = new_node((long long)(i - 1) * m + 1, (long long)i * m - 1);
    while (q--) {
        R(x), R(y); 
        if (y == m) {
            pair t1 = split_lower(last, x - 1);
            pair t2 = split_lower(t1.second, 1);
            W(t2.first->l), write_char('\n');
            last = merge(t1.first, merge(t2.second, t2.first));
        } else {
            pair t1 = split_lower(root[x], y - 1);
            pair t2 = split_upper(t1.second, 1);
            long long pos = t2.first->l + y - t1.first->size - 1;
            long long l = t2.first->l, r = t2.first->r;
            W(pos), write_char('\n');
            node *d1 = new_node(l, pos - 1);
            node *d2 = new_node(pos, pos);
            node *d3 = new_node(pos + 1, r);
            pair t3 = split_lower(last, x - 1);
            pair t4 = split_lower(t3.second, 1);
            last = merge(t3.first, merge(t4.second, d2));
            root[x] = merge(t1.first, merge(merge(merge(d1, d3), 
                t2.second), t4.first));
        }
    }
    flush();
}

int main() {
    solve();
    return 0;
}


然后是线段树的做法，我们用线段树维护，当前区间中已经被用了多少个节点，还是开n + 1棵，表示n行和最后一列，每一次询问哪一个位置是第k个没有使用的位置，如果发现是原来已有的节点，可以直接计算出它的标号，如果是原来没有的节点，我们可以维护n + 1个vector，表示后加入的节点，如果是原来没有的，我们可以根据位置，直接在vector中找到对应的节点，显然vector的总大小是O(q)的，空间不会有问题。线段树的空间，考虑和平衡树一样，动态开点，在访问到的时候再分配，每一次最多增加log个结点，所以时空复杂度都是O(nlogn)

 

Source：

/*
    created by scarlyw
*/
#include <cstdio>
#include <string>
#include <algorithm>
#include <cstring>
#include <iostream>
#include <cmath>
#include <cctype>
#include <vector>
#include <set>
#include <queue>

inline char read() {
    static const int IN_LEN = 1024 * 1024;
    static char buf[IN_LEN], *s, *t;
    if (s == t) {
        t = (s = buf) + fread(buf, 1, IN_LEN, stdin);
        if (s == t) return -1;
    }
    return *s++;
}

///*
template<class T>
inline void R(T &x) {
    static char c;
    static bool iosig;
    for (c = read(), iosig = false; !isdigit(c); c = read()) {
        if (c == -1) return ;
        if (c == '-') iosig = true;	
    }
    for (x = 0; isdigit(c); c = read()) 
        x = ((x << 2) + x << 1) + (c ^ '0');
    if (iosig) x = -x;
}
//*/

const int OUT_LEN = 1024 * 1024;
char obuf[OUT_LEN], *oh = obuf;
inline void write_char(char c) {
    if (oh == obuf + OUT_LEN) fwrite(obuf, 1, OUT_LEN, stdout), oh = obuf;
    *oh++ = c;
}


template<class T>
inline void W(T x) {
    static int buf[30], cnt;
    if (x == 0) write_char('0');
    else {
        if (x < 0) write_char('-'), x = -x;
        for (cnt = 0; x; x /= 10) buf[++cnt] = x % 10 + 48;
        while (cnt) write_char(buf[cnt--]);
    }
}

inline void flush() {
    fwrite(obuf, 1, oh - obuf, stdout);
}

/*
template<class T>
inline void R(T &x) {
    static char c;
    static bool iosig;
    for (c = getchar(), iosig = false; !isdigit(c); c = getchar())
        if (c == '-') iosig = true;	
    for (x = 0; isdigit(c); c = getchar()) 
        x = ((x << 2) + x << 1) + (c ^ '0');
    if (iosig) x = -x;
}
//*/

const int MAXN = 300000 + 10;

struct node {
	int left, right, sum;
} tree[MAXN * 20];

int root[MAXN];
int cnt, id, n, m, q, x, y;
std::vector<long long> val[MAXN];

inline int query(int &cur, int l, int r, int k) {
	if (cur == 0) cur = ++cnt;
	if (l == r) return l;
	int mid = l + r >> 1, temp;
	return ((temp = mid - l + 1 - tree[tree[cur].left].sum) >= k) ? 
				query(tree[cur].left, l, mid, k)
			  : query(tree[cur].right, mid + 1, r, k - temp);
}

inline void modify(int &cur, int l, int r, int pos) {
	if (cur == 0) cur = ++cnt;
	tree[cur].sum++;
	if (l == r) return ;
	int mid = l + r >> 1;
	(pos <= mid) ? modify(tree[cur].left, l, mid, pos)
		 : modify(tree[cur].right, mid + 1, r, pos);
}

inline long long query_l(int x, long long pos) {
	id = query(root[0], 1, n + q, x), modify(root[0], 1, n + q, id);
	long long ans = (id <= n) ? ((long long)id * m) : val[0][id - n - 1];
	return val[0].push_back(pos ? pos : ans), ans;
}

inline long long query_r(int x, int pos) {
	id = query(root[x], 1, m - 1 + q, pos), modify(root[x], 1, m - 1 + q, id);
	long long ans = (id < m) ? ((long long)(x - 1) * m + id) : val[x][id - m];
	return val[x].push_back(query_l(x, ans)), ans;
}

inline void solve() {
	R(n), R(m), R(q);
	for (int i = 1; i <= q; ++i) {
		R(x), R(y);
		W((y != m) ? query_r(x, y) : query_l(x, 0)), write_char('\n');
	}
}

int main() {
	solve();
	flush();
	return 0;
}


最后是标算本意要求的树状数组做法，考虑上面的线段树做法，我们可以比较显然的发现，对于某一行而言，对于这一行的询问是与其他行分开的，也就是说，线段树找空位的操作，第x个空位所在当前行的位置，是不会因为询问顺序而改变的，那么我们就可以离线直接分开处理掉每一行的询问，然后再利用这个树状数组作为最后一行，每一次答案和上面一样，维护n + 1个vector即可，时间复杂度O(nlogn)，空间复杂度O(n)。

 

Source：

/*
    created by scarlyw
*/
#include <cstdio>
#include <string>
#include <algorithm>
#include <cstring>
#include <iostream>
#include <cmath>
#include <cctype>
#include <vector>
#include <set>
#include <queue>

inline char read() {
    static const int IN_LEN = 1024 * 1024;
    static char buf[IN_LEN], *s, *t;
    if (s == t) {
        t = (s = buf) + fread(buf, 1, IN_LEN, stdin);
        if (s == t) return -1;
    }
    return *s++;
}

///*
template<class T>
inline void R(T &x) {
    static char c;
    static bool iosig;
    for (c = read(), iosig = false; !isdigit(c); c = read()) {
        if (c == -1) return ;
        if (c == '-') iosig = true;	
    }
    for (x = 0; isdigit(c); c = read()) 
        x = ((x << 2) + x << 1) + (c ^ '0');
    if (iosig) x = -x;
}
//*/

const int OUT_LEN = 1024 * 1024;
char obuf[OUT_LEN], *oh = obuf;
inline void write_char(char c) {
    if (oh == obuf + OUT_LEN) fwrite(obuf, 1, OUT_LEN, stdout), oh = obuf;
    *oh++ = c;
}


template<class T>
inline void W(T x) {
    static int buf[30], cnt;
    if (x == 0) write_char('0');
    else {
        if (x < 0) write_char('-'), x = -x;
        for (cnt = 0; x; x /= 10) buf[++cnt] = x % 10 + 48;
        while (cnt) write_char(buf[cnt--]);
    }
}

inline void flush() {
    fwrite(obuf, 1, oh - obuf, stdout);
}

/*
template<class T>
inline void R(T &x) {
    static char c;
    static bool iosig;
    for (c = getchar(), iosig = false; !isdigit(c); c = getchar())
        if (c == '-') iosig = true;	
    for (x = 0; isdigit(c); c = getchar()) 
        x = ((x << 2) + x << 1) + (c ^ '0');
    if (iosig) x = -x;
}
//*/

const int MAXN = 300000 + 10;

int n, m, q, x, y, max, low;
int bit[MAXN << 1 | 1], qx[MAXN], qy[MAXN], cur_id[MAXN];

struct node {
	int pos, id;
	node(int pos = 0, int id = 0) : pos(pos), id(id) {}
} ;

std::vector<node> query[MAXN];
std::vector<long long> val[MAXN];

inline void add(int i, int x) {
	for (; i <= max; i += i & -i) bit[i] += x;
}

inline int query_kth(int k) {
	int cur = 0;
	for (int i = low - 1; i >= 0; --i) 
		(cur + (1 << i) <= max && bit[cur + (1 << i)] < k) ? 
			(cur |= (1 << i), k -= bit[cur]) : 0;
	return cur + 1;
}

inline void read_in() {
	R(n), R(m), R(q);
	for (int i = 1; i <= q; ++i) {
		R(x), R(y);
		(y != m) ? (query[x].push_back(node(y, i)), 0) : (0);
		qx[i] = x, qy[i] = y;
	}
	max = std::max(n, m) + q;
	for (int x = 1; x < max; x <<= 1, low++); 	
}

inline void solve_number() {
	for (int i = 1; i <= max; ++i) add(i, 1);
	for (int i = 1; i <= n; ++i) {
		for (int p = 0; p < query[i].size(); ++p) {
			node *cur = &query[i][p];
			cur_id[cur->id] = query_kth(cur->pos), add(cur_id[cur->id], -1);
		}
		for (int p = 0; p < query[i].size(); ++p) {
			node *cur = &query[i][p];
			add(cur_id[cur->id], 1);
		}
	}
}

inline void solve_query() {
	long long cur_ans;
	for (int i = 1; i <= q; ++i) {
		int id = query_kth(qx[i]);
		cur_ans = (id <= n) ? ((long long)id * m) : val[0][id - n - 1];
		add(id, -1);
		if (qy[i] != m) {
			val[qx[i]].push_back(cur_ans);
			cur_ans = (cur_id[i] < m) ? ((long long)(qx[i] - 1) * m + cur_id[i])
				 : val[qx[i]][cur_id[i] - m];
		}
		val[0].push_back(cur_ans), W(cur_ans), write_char('\n');
	}
}

int main() {
	read_in();
	solve_number();
	solve_query();
	flush();
	return 0;
}

总的而言，三种实现方法中，平衡树是最为直接的，线段树是最为好写的，树状数组是效率最高的，都有优势。

 

 

 

scarlyw
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
[NOIP 2017 提高组] 列队
jvruo_shabi的博客
11-09 366
传送门 看到这是NOIP2017tg压轴题，怕了怕了（个鬼）……。 首先我们可以看出这是一个线段树的题目废话，我们先来考虑一个特殊的情况，即 n=1n=1n=1 的情况。 对于这种数据规模，我们肯定暴力艹不过去麻烦作者在考虑超不超时前先考虑数组开的下不，所以，我们又看到 q≤3×105q\leq 3\times 10^5q≤3×105，于是就可以使用一颗线段树来维护： 先将线段树 1∼n1\sim n1∼n 区间每个节点的权值设为这个节点的区间长度（即一开始 1∼n1\sim n1∼n 位置站满了人），对于
NOIP2017D2T3-列队
LiuKairui的博客
07-14 466
问题描述 Sylvia 是一个热爱学习的女孩子。 前段时间，Sylvia 参加了学校的军训。众所周知，军训的时候需要站方阵。 Sylvia 所在的方阵中有 n×m 名学生，方阵的行数为 n，列数为 m。 为了便于管理，教官在训练开始时，按照从前到后，从左到右的顺序给方阵中 的学生从 1 到 n×m 编上了号码（参见后面的样例）。即：初始时，第 i 行第 j 列 的学生的编号是 (i−1)×...
【NOIP2017提高组正式赛】D2T3列队
lijf2001的博客
11-22 1034
Sylvia 是一个热爱学习的女孩子。 前段时间，Sylvia 参加了学校的军训。众所周知，军训的时候需要站方阵。 Sylvia所在的方阵中有n × m名学生，方阵的行数为 n，列数为 m。 为了便于管理，教官在训练开始时，按照从前到后，从左到右的顺序给方阵中从 1 到 n × m 编上了号码（参见后面的样例）。即：初始时，第 i 行第 j 列的学生的编号是(
NOIP2017 列队
weixin_33919941的博客
01-08 248
https://www.luogu.org/problemnew/show/P3960 p<=500 50分 模拟 每个人的出队只会影响当前行和最后一列 p<=500，有用的行只有500行 所以只维护这p行和最后一列的信息 然后模拟 时间复杂度：O（p*(n+m)） 空间复杂度：O（p*m+n） #include<cstdio> #in...
【NOIP2017D2T3】列队
qq_42740027的博客
10-24 209
Description 　　Sylvia 是一个热爱学习的女孩子。 　　前段时间，Sylvia 参加了学校的军训。众所周知，军训的时候需要站方阵。Sylvia所在的方阵中有n × m名学生，方阵的行数为 n，列数为 m。 　　为了便于管理，教官在训练开始时，按照从前到后，从左到右的顺序给方阵中的学生从 1 到 n × m 编上了号码（参见后面的样例）。即：初始时，第 i 行第 j 列的学生的编号是...
[NOIP2017]队列
zsyzClb的博客
11-26 152
这题很简单，只是码量大。 用平衡树维护每一行的前m-1列，用树状数组维护第m列就行了。 用上树状数组的一个优美性质就能优化到nlogn #include <cstdio> #include <cstring> #include <iostream> #include <algorithm> #include <cmath> #define ls tr[x].son[0] #define rs tr[x].son[1] #define LL long
NOIP2017普及组C++试题(无水印版).zip_2017C++真题_noip 2017普及组_noip2017_noip2
07-14
《NOIP2017普及组C++试题详解》 全国青少年信息学奥林匹克联赛（NOIP）是一项旨在激发中学生对计算机科学兴趣、提升编程能力的竞赛。2017年的普及组比赛，主要面向初学者，侧重于基础的算法和编程实践。此资料为...
NOIP2017官方测试数据
11-01
【NOIP2017官方测试数据】是一个与编程竞赛相关的资源，主要针对的是全国青少年信息学奥林匹克联赛（National Olympiad in Informatics in Provinces，简称NOIP）2017年的比赛。NOIP是中国中学生的一项重要信息学...
1.rar（noip2017测试数据）
07-06
【标题】"1.rar（noip2017测试数据）"揭示了这是一个与NOIP比赛相关的测试数据集，存放在一个名为"1.rar"的压缩文件中。NOIP全称为全国青少年信息学奥林匹克联赛（National Olympiad in Informatics in Provinces）...
NOIP2017年普及组_PDF 试题与解题报告.rar
09-18
其次，"NOIP2017普及组复赛试题.pdf"包含了正式比赛的题目，其中"NOIP2017年普及组_第1题 成绩.pdf"、"NOIP2017年普及组_第2题 图书管理员.pdf"、"NOIP2017年普及组_第3题 棋盘.pdf"和"NOIP2017年普及组_第4题 P3957...
NOIP2017普及组参考答案
05-02
### NOIP2017普及组参考答案解析 #### 一、单项选择题解析 根据题目提供的信息，这里并未给出具体的选择题题干内容。不过，我们可以基于NOIP（全国青少年信息学奥林匹克联赛）的考试特点来推测这些选择题可能涉及...
[NOIp 2017]列队
weixin_30951743的博客
12-17 101
Description Sylvia 是一个热爱学习的女孩子。 前段时间，Sylvia 参加了学校的军训。众所周知，军训的时候需要站方阵。 Sylvia 所在的方阵中有$n \times m$名学生，方阵的行数为 $n$，列数为 $m$。 为了便于管理，教官在训练开始时，按照从前到后，从左到右的顺序给方阵中 的学生从 1 到 $n \times m$ 编上了号码（参见后面的样例）。即：初始...
【NOIP2017】列队
Ashley_2013的博客
10-22 143
题面 分析 知名数据结构题。 今天拿给我做我还是会毫不犹豫地敲个50的暴力吧，因为细节其实是很多的。 考虑维护n+1棵线段树，前n棵维护n排的m-1个人，最后一棵维护最后一列的n个人 每次坐标为（x,y）的一个人离开队伍，相当于把这个人取出来放到最后一列的最后一个位置。 然后就这样就完了吗？原来第x行的最后一个位置，这时应该成为了倒数第二个位置，换言之，它本来不在第x棵线...
NOIP2017_D2T3 列队
FatetoEternity的博客
10-29 338
题目略（各大OJ上都有） 题解： 我们可以观察到一个规律，就是每次移动都只会改变一行和最后一列（最后一列是关键），于是我们就可以把这个方阵划分成这样 每个划分的区间只需要快速支持这两个操作： 从中查询一个位置的值并删除 向末尾添加一个值 因为最多只有q个添加操作，q有3×1053 \times 10^53×105而一个序列原本就有3×1053 \times 10^53×105这么长,用高级数据...
[NOIP2017]列队 （Splay）
weixin_34402408的博客
09-11 99
题目链接 NOIP2017真的是不按常理出牌： 1、数学题不在Day2T1 2、一道水题一道细节极多的模拟题一道不知道怎么形容的题（小凯的疑惑）（因为我太菜了） 3、3道大火题 当时看到列队这题是毫无头绪的，因为数据大得让你存都存不下，于是果断打了个30分暴力（如果打个离散化还能多骗20分）。 蓦然回首，豁然开朗。 思考可知，一个人出列影响的只是当前一行和最后一列，于是，我们只需要对每一行和最后一...
NOIP2017提高组D2T3[列队]
HHzzkk2003的博客
11-22 645
题意： 给一个n行m列的方阵，第i行第j列的人编号为(i-1)*m+j，每次会有一个人出列，所有人先向m=1一列补齐，再向n=1一行补齐，然后出列的人补在n行m列，问每次出列的人的编号。 题解： 平衡树动态开节点，每行前m-1个人记录一个平衡树，最后一列单独记一个平衡树，最好用Splay或者无旋Treap。 代码： #include #include #include #inclu
noip2017列队（线段树）
10-08 102
维护一个方阵，支持 1.删掉一个点，剩下的点先向左看齐再向前看齐 2.询问一个位置上是哪个点 $n,m,q \leq 3 \times 10^5$ sol： 我们每行前$m-1$列维护一个线段树，最后一列维护一棵线段树 然后搞n + 1个vector 这个线段树只需要维护“这个节点下面有多少点已经被删除了” 删除最后一列时，删掉一个点然后pushback即可 非最后一列...
noip2017 列队 题解
weixin_42465242的博客
07-25 149
使用线段树。 对于取走序列中的一个数并放到尾部这样的操作，我们可以使用数组和线段树解决，方法如下： 例：1 7 3 5 7 3 取走5，放到尾部。1 7 3 5 7 3 --> 1 7 3 __ 7 3 5 （下划线表示空） 但这样查询第K个数时不能直接访问数组中的第K个元素（因为有空格），而扫一遍的复杂度又太高，所以要使用线段树进行优化，方法如下： 维护另外一个数组，数组中只有0...
[NOIP2017]列队（树状数组）
weixin_34411563的博客
07-21 165
定义第i行为所有的点（i，j），0<j<m 可以发现，每一行是相对独立的，每一次操作只会影响到当前行和最后一列 考虑每一行和最后一列各开一个树状数组，但这样显然会爆空间 实际上，对于没有离队过的点是没必要储存的，可以直接算出编号， 因此只要用vector储存每一行和最后一列后加入的点即可 还需要预处理一个数组d[i]表示第i次询问当前行的离队的点的纵坐标 这个可以离线做出来...
【NOIP2017普及t3】棋盘
最新发布
07-08
你好！感谢你的提问。根据你的要求，我将为你解答关于NOIP2017普及t3问题的内容。 在这道题目中，我们需要解决一个关于棋盘的问题。题目描述了一个n×m的棋盘，每个格子上有一个非负整数。开始时，小明站在左上角的格子上，他可以向右或向下移动一步，每次移动的代价为目标格子上的数值。我们需要找到一条从左上角到右下角的路径，使得移动的总代价最小。 解决这个问题的一个常见的方法是使用动态规划（Dynamic Programming）。我们可以创建一个二维数组dp，其中dp[i][j]表示从起点到达坐标为(i, j)的格子时的最小代价。然后，我们可以按照从左上角到右下角的顺序依次计算dp数组的值。 具体的计算方法如下： 1. 首先，我们可以初始化dp数组的第一行和第一列，即dp[0][j]和dp[i][0]，它们表示从起点到达第一行和第一列的格子时的最小代价。初始化的方法是累加前面的格子的代价。 2. 接下来，我们可以使用一个双重循环，从(1, 1)开始遍历整个棋盘。对于每个格子(i, j)，我们可以选择从上方格子(i-1, j)或左方格子(i, j-1)中选择一个代价较小的路径，并加上当前格子的代价。即dp[i][j] = min(dp[i-1][j], dp[i][j-1]) + grid[i][j]。 3. 最后，当我们计算完dp数组的所有值后，dp[n-1][m-1]即为从起点到达右下角的格子时的最小代价。 这样，我们就可以得到从左上角到右下角的最小代价。希望能对你的问题有所帮助！如果你还有其他问题，请随时提问。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值