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)); }