int main() {
int n, q;
scanf("%d%d", &n, &q);
memset(&tree, 0, sizeof(tree));
for(int i = 1; i <= n; i++)
scanf("%d", &A[i]);
tree.build(1, 1, n);
int k, args[20], original[20];
char cmd[100];
while(q--) {
scanf("%s", cmd);
// 解析输入
int len = strlen(cmd);
k = 0; args[k] = 0;
for(int i = 6; i < len; i++)
if(isdigit(cmd[i])) args[k] = args[k] * 10 + cmd[i] - '0';
else { k++; args[k] = 0; }
// 处理命令
if(cmd[0] == 'q') {
qL = args[0]; qR = args[1];
printf("%d\n", tree.query(1, 1, n));
} else {
for(int i = 0; i < k; i++) original[i] = A[args[i]];
for(int i = 0; i < k; i++) {
p = args[i];
v = A[p] = original[(i+1)%k];
tree.update(1, 1, n);
}
}
}
return 0;
}
void initialize(int n, int q) {
uf.reset(n);
tree.reset(1, q);
stkpos = 1;
stk[1] = tree.root();
}
TEST(IntervalTest, Merging3)
{
IntervalTree tree;
tree.Insert(Interval(1, 3));
tree.Insert(Interval(5, 6));
tree.Insert(Interval(4, 6));
EXPECT_EQ(tree.size(), 2);
}
TEST(IntervalTest, ZMW25300)
{
IntervalTree tree;
tree.Insert(Interval(252, 295));
tree.Insert(Interval(293, 338));
for (const auto& i : tree)
{
EXPECT_EQ(i.Left(), 252);
EXPECT_EQ(i.Right(), 338);
}
}
TEST(IntervalTest, Merging)
{
IntervalTree tree;
tree.Insert(Interval(1, 3));
tree.Insert(Interval(3, 5));
EXPECT_EQ(tree.size(), 1);
for (const auto& i : tree)
{
EXPECT_EQ(i.Right(), 5);
EXPECT_EQ(i.Left(), 1);
}
}
bool PCLibraryState::cacheLibraryRanges(Library::ptr lib)
{
std::string filename = lib->getName();
Address base = lib->getLoadAddress();
SymbolReaderFactory *fact = getDefaultSymbolReader();
SymReader *reader = fact->openSymbolReader(filename);
if (!reader) {
sw_printf("[%s:%u] - Error could not open expected file %s\n",
FILE__, __LINE__, filename.c_str());
return false;
}
int num_segments = reader->numSegments();
for (int i=0; i<num_segments; i++) {
SymSegment segment;
reader->getSegment(i, segment);
if (segment.type != 1) continue;
Address segment_start = segment.mem_addr + base;
Address segment_end = segment_start + segment.mem_size;
loadedLibs.insert(segment_start, segment_end,
makeCache(LibAddrPair(lib->getName(),
lib->getLoadAddress()),
lib));
}
return true;
}
static SortedRanges partialMerging(const IntervalTree<ElemChunk> &tree, const dav_size_t mergedist) {
MergedRanges merged;
std::vector<Interval<ElemChunk> > allranges_unsorted;
tree.findContained(0, std::numeric_limits<dav_size_t>::max(), allranges_unsorted);
MergedRanges allranges;
for(std::vector<Interval<ElemChunk> >::iterator it = allranges_unsorted.begin(); it != allranges_unsorted.end(); it++)
allranges.insert(std::make_pair(it->start, it->stop));
dav_off_t offset = allranges.begin()->first;
dav_off_t end = allranges.begin()->second;
for(MergedRanges::iterator it = allranges.begin(); it != allranges.end(); it++) {
if(end + (dav_off_t) mergedist >= it->first) {
end = it->second;
}
else {
merged.insert(std::make_pair(offset, end));
offset = it->first;
end = it->second;
}
}
merged.insert(std::make_pair(offset, end));
SortedRanges output;
for(MergedRanges::iterator it = merged.begin(); it != merged.end(); it++)
output.push_back(*it);
return output;
}
void testBoundaries()
{
// 1. Create new lock and acquire lock from 1-10
IntervalTree<int, LockHolder> tree;
LockHolder lockA('A');
tree.addInterval(1, 10, lockA);
// 2. Create lock B on the edge
LockHolder lockB('B');
tree.addInterval(10, 15, lockB);
//3. Query the edge
std::list<LockHolder> result = tree.getIntervalSet(10, 10);
printResultSet(result);
assert((result.size() == 1) && (result.front() == 'B'));
}
TEST(IntervalTest, Gaps3)
{
IntervalTree tree;
tree.Insert(Interval(3, 5));
tree.Insert(Interval(7, 9));
IntervalTree gaps = tree.Gaps(Interval(4, 9));
EXPECT_EQ(gaps.size(), 1);
for (const auto& i : gaps)
{
EXPECT_EQ(i.Left(), 5);
EXPECT_EQ(i.Right(), 7);
}
}
void printTree(IntervalTree<T,U> &tree)
{
#ifdef DEBUG
std::cout << "============= tree ============" << std::endl;
tree.printTree(std::cout);
std::cout << "============= ============" << std::endl;
#endif
}
void testRemoveInterval()
{
int arr[][2] ={
{1888,1971},
{1874,1951},
{1843,1907},
{1779,1828},
{1756,1791},
{1585, 1672}
};
Node a(1888, 1971);
Node b(1874, 1951);
Node c(1843, 1907);
Node d(1779, 1828);
Node e(1756, 1791);
Node f(1585, 1672);
IntervalTree<int,Node> tree;
for(size_t i=0; i < ARRAY_SIZE(arr); i++) {
Node nd (arr[i][0], arr[i][1]);
tree.addInterval( arr[i][0], arr[i][1], nd);
}
printTree(tree);
std::list<Node> result;
{
tree.removeInterval(1951, 1972, a);
result = tree.getIntervalSet(1960, 1970);
assert(result.size() == 0);
}
{
result = tree.getIntervalSet(1890, 1900);
assert(result.size() == 3);
assert(popNode(result, c) && popNode(result, b) && popNode(result, a));
}
{
tree.removeInterval(1875, 1890, c);
result = tree.getIntervalSet(1877, 1889);
assert(!hasNode(result, c));
}
{
result = tree.getIntervalSet(1906, 1910);
assert(result.size() == 3);
assert(hasNode(result, a));
assert(hasNode(result, b));
assert(hasNode(result, c));
}
}
int main() {
int n, m;
while(scanf("%d%d", &n, &m) == 2) {
memset(&tree, 0, sizeof(tree));
while(m--) {
scanf("%d", &op);
if(op == 1) {
scanf("%d%d", &p, &v);
tree.update(1, 1, n);
} else {
scanf("%d%d", &qL, &qR);
printf("%d\n", tree.query(1, 1, n));
}
}
}
return 0;
}
void PCLibraryState::removeLibFromCache(cache_t element) {
IntervalTree<Address, cache_t>::iterator iter = loadedLibs.begin();
while(iter != loadedLibs.end()) {
// Can't use a for loop because I need to fiddle with
// increments manually.
cache_t found = iter->second.second;
if (found == element) {
IntervalTree<Address, cache_t>::iterator toDelete = iter;
++iter;
loadedLibs.erase(toDelete->first);
}
else {
++iter;
}
}
}
void add_connection(int u, int v, int t) {
current++;
Edge *e = new Edge(u, v);
tree.modify(current, current + t - 1, e);
if (current == 1)
add_node(stk[1]);
}
i64 solve(vector<Rect> rects){
compress(rects);
vector<Event> evs = eventsFromRect(rects);
i64 total = 0;
IntervalTree::Node root = {1, 0, (int)xs.size() - 2};
tree.init(root);
for (size_t i = 0; i < evs.size(); i++){
Event &e = evs[i];
if (i != 0){
i64 s = tree.gao(0, (int)xs.size() - 2).query(root, k);
//printf("%lld\n", s);
total += s * (ys[evs[i].tick] - ys[evs[i - 1].tick]);
}
//e.debug();
//printf("%lu: %lld\n", i, total);
tree.gao(e.from, e.to).add(root, e.inc);
}
return total;
}
bool PCLibraryState::checkLibraryContains(Address addr, Library::ptr lib)
{
cacheLibraryRanges(lib);
cache_t tmp;
bool ret = loadedLibs.find(addr, tmp);
if (ret && tmp.second == lib)
return true;
return false;
}
int main() {
int kase = 0, n, a, Q;
while(scanf("%d%d", &n, &Q) == 2) {
prefix_sum[0] = 0;
for(int i = 0; i < n; i++) {
scanf("%d", &a);
prefix_sum[i+1] = prefix_sum[i] + a;
}
tree.build(1, 1, n);
printf("Case %d:\n", ++kase);
while(Q--) {
int L, R;
scanf("%d%d", &L, &R);
qL = L; qR = R;
Interval ans = tree.query(1, 1, n);
printf("%d %d\n", ans.first, ans.second);
}
}
return 0;
}
// find all matching chunks in tree and fill them
static void fillChunks(const char *source, const IntervalTree<ElemChunk> &tree, dav_off_t offset, dav_size_t size) {
std::vector<Interval<ElemChunk> > matches;
tree.findOverlapping(offset, offset+size-1, matches);
for(std::vector<Interval<ElemChunk> >::iterator it = matches.begin(); it != matches.end(); it++) {
copyBytes(source, offset, size, it->value);
}
if(matches.size() == 0) {
DAVIX_SLOG(DAVIX_LOG_DEBUG, DAVIX_LOG_CHAIN, "WARNING: Received byte-range from server does not match any in the interval tree");
}
}
void connect(int A, int B)
{
City *paA = cities[A].getPa(), *paB = cities[B].getPa();
if(paA == paB) return;
assert(paB->minY <= paB->maxY);
if(paB->minY != paB->maxY)
{
tree1.Add(-1, paB->minY, paB->maxY - 1);
tree2.Add(-paB->size, paB->minY, paB->maxY - 1);
}
if(paA->minY != paA->maxY)
{
tree1.Add(-1, paA->minY, paA->maxY - 1);
tree2.Add(-paA->size, paA->minY, paA->maxY - 1);
}
paA->size += paB->size;
paB->ppa = paA;
paA->minY = min(paA->minY, paB->minY);
paA->maxY = max(paA->maxY, paB->maxY);
assert(paA->minY <= paA->maxY);
if(paA->minY != paA->maxY)
{
tree1.Add(1, paA->minY, paA->maxY - 1);
tree2.Add(paA->size, paA->minY, paA->maxY - 1);
}
}
int main(){
int T; scanf("%d", &T);
while (T--){
scanf("%d", &N);
for (int i = 0; i < N; i++) scanf("%d %d", &x[i], &y[i]);
ds.init();
citysTree.init();
stateTree.init();
int M; scanf("%d", &M);
while (M--){
char cmd[32]; scanf("%s", cmd);
if (!strcmp(cmd, "road")){
int A, B; scanf("%d%d", &A, &B);
int pA = ds.find(A), pB = ds.find(B);
if (pA != pB){
citysTree.gao(ds._min[pA], ds._max[pA] - 1).add(1, 0, maxrange, -ds._cnt[pA], false);
stateTree.gao(ds._min[pA], ds._max[pA] - 1).add(1, 0, maxrange, -1, false);
citysTree.gao(ds._min[pB], ds._max[pB] - 1).add(1, 0, maxrange, -ds._cnt[pB], false);
stateTree.gao(ds._min[pB], ds._max[pB] - 1).add(1, 0, maxrange, -1, false);
//cout << citysTree.gao(0, maxrange).query(1, 0, maxrange) << endl;
int pC = ds.join(A, B);
//cout << ds._cnt[pC] << ": " << ds._min[pC] << ", " << ds._max[pC] << endl;
citysTree.gao(ds._min[pC], ds._max[pC] - 1).add(1, 0, maxrange, ds._cnt[pC], false);
stateTree.gao(ds._min[pC], ds._max[pC] - 1).add(1, 0, maxrange, 1, false);
//cout << citysTree.gao(0, maxrange).query(1, 0, maxrange) << endl;
}
}else{
assert(!strcmp(cmd, "line"));
double dC; scanf("%lf", &dC);
int C = floor(dC);
//cout << C << endl;
int citysNum = citysTree.gao(C, C).query(1, 0, maxrange);
int stateNum = stateTree.gao(C, C).query(1, 0, maxrange);
printf("%d %d\n", stateNum, citysNum);
}
}
}
}
void testStringIntervals()
{
IntervalTree<char, String> tree;
tree.addInterval('a', 'c', string("ac"));
tree.addInterval('a', 'f', string("af"));
tree.addInterval('d', 'k', string("dk"));
tree.addInterval('d', 'l', string("dl"));
tree.addInterval('d', 'o', string("do"));
tree.addInterval('t', 'z', string("tz"));
printTree(tree);
std::list<String> result;
{
result = tree.getIntervalSet('b', 'g');
assert(result.size() == 5);
assert(!hasNode(result, String(string("tz"))));
}
{
result = tree.getIntervalSet('k', 'z');
assert(result.size() == 3);
assert(hasNode(result, String(string("dl"))));
assert(hasNode(result, String(string("do"))));
assert(hasNode(result, String(string("tz"))));
printResultSet(result);
}
}
void solve()
{
int n = readint();
tree1.init(MAXC);
tree2.init(MAXC);
int i = 0;
for(i = 0; i < n; i++)
{
City *p = &(cities[i]);
readint();
p->y = readint();
p->ppa = p;
p->minY = p->y;
p->maxY = p->y;
p->size = 1;
}
int m = readint();
char cmd[16];
for(i = 0; i < m; i++)
{
scanf("%s", cmd);
if(cmd[0] == 'r')
{
int A, B;
A = readint(), B = readint();
connect(A, B);
}
else if(cmd[0] = 'l')
{
float C;
scanf("%f", &C);
int y = (int)C;
pair<int, int> sd = make_pair(tree1.query(y, y), tree2.query(y, y));
printf("%d %d\n", sd.first, sd.second);
}
}
}
TEST(IntervalTest, Gaps2)
{
IntervalTree tree;
tree.Insert(Interval(3, 9));
IntervalTree gaps = tree.Gaps(Interval(5, 11));
EXPECT_EQ(gaps.size(), 1);
for (auto& i : gaps)
{
EXPECT_EQ(i.Left(), 9);
EXPECT_EQ(i.Right(), 11);
}
gaps = tree.Gaps(Interval(1, 11));
EXPECT_EQ(gaps.size(), 2);
size_t l = 1;
size_t r = 3;
for (const auto& i : gaps)
{
EXPECT_EQ(i.Left(), l);
EXPECT_EQ(i.Right(), r);
l += 8;
r += 8;
}
gaps = tree.Gaps(Interval(11, 15));
EXPECT_EQ(gaps.size(), 1);
for (const auto& i : gaps)
{
EXPECT_EQ(i.Left(), 11);
EXPECT_EQ(i.Right(), 15);
}
}
void testNames()
{
IntervalTree<char, string> tree;
tree.addInterval('j', 'y', string("jojy"));
tree.addInterval('b', 'n', string("brian"));
tree.addInterval('e', 's', string("sage"));
tree.addInterval('f', 'g', string("gregsf"));
tree.addInterval('h', 'y', string("yehudah"));
printTree(tree);
std::list<string> result;
{
result = tree.getIntervalSet('b', 'y');
assert(result.size() == 5);
printResultSet(result);
}
{
result = tree.getIntervalSet('j', 'm');
assert(!hasNode(result, string("gregsf")));
printResultSet(result);
}
{
tree.removeAll("jojy");
result = tree.getIntervalSet('b', 'z');
assert(!hasNode(result, string("jojy")));
printResultSet(result);
}
}
bool PCLibraryState::findInCache(Process::ptr proc, Address addr, LibAddrPair &lib) {
cache_t tmp;
if (!loadedLibs.find(addr, tmp)) {
return false;
}
Library::ptr lib_ptr = tmp.second;
if (proc->libraries().find(lib_ptr) != proc->libraries().end()) {
lib = tmp.first;
return true;
}
removeLibFromCache(tmp);
return false;
}
void testIntervalQuery()
{
int arr[][2] ={
{1888,1971},
{1874,1951},
{1843,1907},
{1779,1828},
{1756,1791},
{1585, 1672}
};
Node a(1888, 1971);
Node b(1874, 1951);
Node c(1843, 1907);
Node d(1779, 1828);
Node e(1756, 1791);
Node f(1585, 1672);
IntervalTree<int,Node> tree;
for(size_t i=0; i < ARRAY_SIZE(arr); i++) {
Node nd (arr[i][0], arr[i][1]);
tree.addInterval( arr[i][0], arr[i][1], nd);
}
std::list<Node> result = tree.getIntervalSet(1843, 1874);
assert(result.size() == 1 && (result.front() == c));
result = tree.getIntervalSet(1873, 1974);
assert(result.size() == 3);
assert(popNode(result, c) && popNode(result,b) && popNode(result,a));
result = tree.getIntervalSet(1910, 1910);
assert(result.size() == 2);
assert(popNode(result, b) && popNode(result,a));
result = tree.getIntervalSet(1829, 1842);
assert(result.size() == 0);
result = tree.getIntervalSet(1829, 1845);
assert(result.size() == 1);
assert(popNode(result, c));
}
void testRemoveFromMiddle()
{
// 1. Create new lock and acquire lock from 1-10
IntervalTree<int, LockHolder> tree;
LockHolder lockA('A');
tree.addInterval(1, 10, lockA);
// 2. Create lock B on the edge
LockHolder lockB('B');
tree.addInterval(10, 15, lockB);
// 3. Remove all locks from 6-12
tree.removeInterval(6, 12);
//4. Query the removed interval
std::list<LockHolder> result = tree.getIntervalSet(6, 11);
assert(result.size() == 0);
//5. Query the interval locked by A
result = tree.getIntervalSet(2, 5);
assert((result.size() == 1) && (result.front() == 'A'));
}
TEST(IntervalTest, Gaps)
{
IntervalTree tree;
tree.Insert(Interval(1, 3));
tree.Insert(Interval(5, 7));
tree.Insert(Interval(9, 11));
IntervalTree gaps = tree.Gaps();
EXPECT_EQ(gaps.size(), 2);
size_t l = 3;
size_t r = 5;
for (const auto& i : gaps)
{
EXPECT_EQ(i.Left(), l);
EXPECT_EQ(i.Right(), r);
l += 4;
r += 4;
}
}
void algorithm2(vector<Square> & squares){
priority_queue<Event, vector<Event>, CompareEvent> events;
//vector<SQINTERVAL> intervals; // vector containg all vertical intervals and their rectangles
IntervalTree<Square, float> activeTree; // tree containing the vertical intervals
vector<SQINTERVAL> results; // contains the intersecting vertical intervals and their rectangles
ofstream output;
output.open("uitvoerrechthoeken.txt");
// start timer
auto start = std::chrono::steady_clock::now();
for (int i = 0; i < squares.size(); i++){
Event e1 = Event(true, squares[i], squares[i].getLB().getX());
Event e2 = Event(false, squares[i], squares[i].getRA().getX());
events.push( e1 ); //left side event of rectangle
events.push( e2 ); //right side event of rectangle
}
while (!events.empty()) {
Event current = events.top();
if (current.isLeftEdge()){
if (activeTree.getIntervals().size() > 0){
activeTree.findOverlapping(current.getSquare().getLB().getY(), current.getSquare().getRA().getY(), results);
vector<Coordinate> pos;
for (int i = 0; i < results.size(); i++){
results[i].value.getIntersection(current.getSquare(), pos);
for (int w = 0; w < pos.size(); w++){
output << pos[w].getX() << " " << pos[w].getY() << "\n";
}
pos.clear();
}
}
activeTree.addInterval(SQINTERVAL(current.getSquare().getInterval()));
activeTree.sort();
results.clear();
}
else {
for (vector<SQINTERVAL>::iterator i = activeTree.getIntervals().begin(); i != activeTree.getIntervals().end(); ++i){
if (current.getSquare().getId() == i->value.getId()){
activeTree.getIntervals().erase(i);
break;
}
}
results.clear();
}
events.pop();
}
// stop timer
auto end = std::chrono::steady_clock::now();
auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
output << elapsed.count() << "\n";
output.close();
cout << "Ready. \n";
cout << elapsed.count();
}
void testLocks()
{
// 1. Create new lock and acquire lock from 1-10
IntervalTree<int, LockHolder> tree;
LockHolder lockA('A');
tree.addInterval(1, 10, lockA);
printTree(tree);
std::list<LockHolder> result;
{
result = tree.getIntervalSet(1,10);
assert(result.size() == 1);
printResultSet(result);
}
// Create new lock and acquire from 3-15
LockHolder lockB('B');
tree.addInterval(3, 15, lockB);
{
result = tree.getIntervalSet(1,15);
assert(result.size() == 2);
}
// Release all locks from 3-10
tree.removeInterval(3,10);
// Query the whole range
result = tree.getIntervalSet(1,15);
assert(result.size() == 2 && (result.front() == 'A') );
result.pop_front();
assert(result.front() == 'B');
// Query the range held by only A
result = tree.getIntervalSet(1,5);
assert(result.front().name == 'A');
// Query the range held by none
result = tree.getIntervalSet(4,9);
printResultSet(result);
assert(!result.size());
// Again acquire lock B from 3-15
tree.addInterval(3, 15, lockB);
result = tree.getIntervalSet(1,15);
assert(result.size() ==2);
// Query the range held by only B
result = tree.getIntervalSet(4,10);
assert((result.size() ==1) && (result.front().name == 'B'));
// Again acquire lock A from 3-10
tree.addInterval(3, 10, lockA);
result = tree.getIntervalSet(3,10);
assert(result.size() ==2);
// Release only locks held by B from 3-10
tree.removeInterval(3,10, lockB);
// Query interval just released by B
result = tree.getIntervalSet(3,9);
assert((result.size() ==1) && (result.front().name == 'A'));
// Query interval now partially owned by B
result = tree.getIntervalSet(3,12);
assert(result.size() ==2);
// Add one more lock between 4-8
LockHolder lockC('C');
tree.addInterval(4, 8, lockC);
printTree(tree);
// Query the interval shared by A,B,C
result = tree.getIntervalSet(3,12);
assert(result.size() ==3);
// Query the intervals shared by A, C
result = tree.getIntervalSet(3, 6);
assert(result.size() == 2 && (result.front() == 'A') );
result.pop_front();
assert(result.front() == 'C');
// Add one more lock between 2-4
LockHolder lockD('D');
tree.addInterval(2, 4, lockD);
// Query the intervals owned by A.B,C,D
result = tree.getIntervalSet(2, 11);
assert(result.size () == 4);
assert(popNode(result, lockA) && popNode(result, lockB) && popNode(result, lockC) && popNode(result, lockD));
}
