Skip to content

Commit 0516527

Browse files
yanglbmeyanglbme
committed
feat: add solutions to lc problem: No.1622
No.1622.Fancy Sequence
1 parent 3f3c528 commit 0516527

File tree

37 files changed

+11758
-8904
lines changed

37 files changed

+11758
-8904
lines changed

‎solution/1600-1699/1622.Fancy Sequence/README.md

Lines changed: 396 additions & 0 deletions
Large diffs are not rendered by default.

‎solution/1600-1699/1622.Fancy Sequence/README_EN.md

Lines changed: 396 additions & 0 deletions
Large diffs are not rendered by default.

‎solution/1600-1699/1622.Fancy Sequence/Solution.cpp

Lines changed: 134 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,134 @@
1+
const int MOD = 1e9 + 7;
2+
3+
class SegmentTree {
4+
private:
5+
int l;
6+
int r;
7+
SegmentTree* left;
8+
SegmentTree* right;
9+
long long v;
10+
long long add;
11+
long long mul;
12+
13+
public:
14+
SegmentTree(int l, int r) {
15+
this->l = l;
16+
this->r = r;
17+
this->left = nullptr;
18+
this->right = nullptr;
19+
this->v = 0;
20+
this->add = 0;
21+
this->mul = 1;
22+
}
23+
24+
void modifyAdd(int l, int r, int inc) {
25+
if (l > r) return;
26+
if (this->l >= l && this->r <= r)
27+
{
28+
v = (v + (this->r - this->l + 1) * inc) % MOD;
29+
add = (add + inc) % MOD;
30+
return;
31+
}
32+
pushdown();
33+
int mid = _mid();
34+
if (l <= mid) _left()->modifyAdd(l, r, inc);
35+
if (r > mid) _right()->modifyAdd(l, r, inc);
36+
pushup();
37+
}
38+
39+
void modifyMul(int l, int r, int m) {
40+
if (l > r) return;
41+
if (this->l >= l && this->r <= r)
42+
{
43+
v = (v * m) % MOD;
44+
add = (add * m) % MOD;
45+
mul = (mul * m) % MOD;
46+
return;
47+
}
48+
pushdown();
49+
int mid = _mid();
50+
if (l <= mid) _left()->modifyMul(l, r, m);
51+
if (r > mid) _right()->modifyMul(l, r, m);
52+
pushup();
53+
}
54+
55+
int query(int l, int r) {
56+
if (l > r) return 0;
57+
if (this->l >= l && this->r <= r) return v;
58+
pushdown();
59+
int mid = _mid();
60+
int v = 0;
61+
if (l <= mid) v = (v + _left()->query(l, r)) % MOD;
62+
if (r > mid) v = (v + _right()->query(l, r)) % MOD;
63+
return v;
64+
}
65+
66+
int _mid() {
67+
return (l + r) >> 1;
68+
}
69+
70+
SegmentTree* _left() {
71+
if (!left) left = new SegmentTree(l, _mid());
72+
return left;
73+
}
74+
75+
SegmentTree* _right() {
76+
if (!right) right = new SegmentTree(_mid() + 1, r);
77+
return right;
78+
}
79+
80+
void pushup() {
81+
v = (_left()->v + _right()->v) % MOD;
82+
}
83+
84+
void pushdown() {
85+
if (add != 0 || mul != 1)
86+
{
87+
_left()->v = (_left()->v * mul + (_left()->r - _left()->l + 1) * add) % MOD;
88+
_right()->v = (_right()->v * mul + (_right()->r - _right()->l + 1) * add) % MOD;
89+
_left()->add = (_left()->add * mul + add) % MOD;
90+
_right()->add = (_right()->add * mul + add) % MOD;
91+
_left()->mul = (_left()->mul * mul) % MOD;
92+
_right()->mul = (_right()->mul * mul) % MOD;
93+
add = 0;
94+
mul = 1;
95+
}
96+
}
97+
};
98+
99+
class Fancy {
100+
public:
101+
int n;
102+
SegmentTree* tree;
103+
104+
Fancy() {
105+
this-> n = 0;
106+
tree = new SegmentTree(1, 1e5 + 1);
107+
}
108+
109+
void append(int val) {
110+
++this->n;
111+
tree->modifyAdd(this->n, this->n, val);
112+
}
113+
114+
void addAll(int inc) {
115+
tree->modifyAdd(1, this->n, inc);
116+
}
117+
118+
void multAll(int m) {
119+
tree->modifyMul(1, this->n, m);
120+
}
121+
122+
int getIndex(int idx) {
123+
return idx >= this-> n ? -1 : tree->query(idx + 1, idx + 1);
124+
}
125+
};
126+
127+
/**
128+
* Your Fancy object will be instantiated and called as such:
129+
* Fancy* obj = new Fancy();
130+
* obj->append(val);
131+
* obj->addAll(inc);
132+
* obj->multAll(m);
133+
* int param_4 = obj->getIndex(idx);
134+
*/

‎solution/1600-1699/1622.Fancy Sequence/Solution.java

Lines changed: 146 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,146 @@
1+
class Fancy {
2+
private int n;
3+
private SegmentTree tree;
4+
5+
public Fancy() {
6+
tree = new SegmentTree(1, (int) 1e5 + 1);
7+
}
8+
9+
public void append(int val) {
10+
++n;
11+
tree.modifyAdd(n, n, val);
12+
}
13+
14+
public void addAll(int inc) {
15+
tree.modifyAdd(1, n, inc);
16+
}
17+
18+
public void multAll(int m) {
19+
tree.modifyMul(1, n, m);
20+
}
21+
22+
public int getIndex(int idx) {
23+
return idx >= n ? -1 : tree.query(idx + 1, idx + 1);
24+
}
25+
}
26+
27+
class SegmentTree {
28+
private int l;
29+
private int r;
30+
private SegmentTree left;
31+
private SegmentTree right;
32+
private long v;
33+
private long add;
34+
private long mul = 1;
35+
private static final int MOD = (int) 1e9 + 7;
36+
37+
public SegmentTree(int l, int r) {
38+
this.l = l;
39+
this.r = r;
40+
}
41+
42+
public void pushup() {
43+
v = (left().v + right().v) % MOD;
44+
}
45+
46+
public int mid() {
47+
return (l + r) >> 1;
48+
}
49+
50+
public SegmentTree left() {
51+
if (left == null) {
52+
left = new SegmentTree(l, mid());
53+
}
54+
return left;
55+
}
56+
57+
public SegmentTree right() {
58+
if (right == null) {
59+
right = new SegmentTree(mid() + 1, r);
60+
}
61+
return right;
62+
}
63+
64+
public void modifyAdd(int l, int r, int inc) {
65+
if (l > r) {
66+
return;
67+
}
68+
if (this.l >= l && this.r <= r) {
69+
v = (v + (this.r - this.l + 1) * inc) % MOD;
70+
add = (add + inc) % MOD;
71+
return;
72+
}
73+
pushdown();
74+
int mid = mid();
75+
if (l <= mid) {
76+
left().modifyAdd(l, r, inc);
77+
}
78+
if (r > mid) {
79+
right().modifyAdd(l, r, inc);
80+
}
81+
pushup();
82+
}
83+
84+
public void modifyMul(int l, int r, int m) {
85+
if (l > r) {
86+
return;
87+
}
88+
if (this.l >= l && this.r <= r) {
89+
v = (v * m) % MOD;
90+
add = (add * m) % MOD;
91+
mul = (mul * m) % MOD;
92+
return;
93+
}
94+
pushdown();
95+
int mid = mid();
96+
if (l <= mid) {
97+
left().modifyMul(l, r, m);
98+
}
99+
if (r > mid) {
100+
right().modifyMul(l, r, m);
101+
}
102+
pushup();
103+
}
104+
105+
public int query(int l, int r) {
106+
if (l > r) {
107+
return 0;
108+
}
109+
if (this.l >= l && this.r <= r) {
110+
return (int) v;
111+
}
112+
pushdown();
113+
int mid = mid();
114+
long v = 0;
115+
if (l <= mid) {
116+
v += left().query(l, r);
117+
}
118+
if (r > mid) {
119+
v += right().query(l, r);
120+
}
121+
return (int) v % MOD;
122+
}
123+
124+
public void pushdown() {
125+
SegmentTree left = left(), right = right();
126+
if (add != 0 || mul != 1) {
127+
left.v = (left.v * mul + (left.r - left.l + 1) * add) % MOD;
128+
right.v = (right.v * mul + (right.r - right.l + 1) * add) % MOD;
129+
left.add = (left.add * mul + add) % MOD;
130+
right.add = (right.add * mul + add) % MOD;
131+
left.mul = (left.mul * mul) % MOD;
132+
right.mul = (right.mul * mul) % MOD;
133+
add = 0;
134+
mul = 1;
135+
}
136+
}
137+
}
138+
139+
/**
140+
* Your Fancy object will be instantiated and called as such:
141+
* Fancy obj = new Fancy();
142+
* obj.append(val);
143+
* obj.addAll(inc);
144+
* obj.multAll(m);
145+
* int param_4 = obj.getIndex(idx);
146+
*/

‎solution/1600-1699/1622.Fancy Sequence/Solution.py

Lines changed: 111 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,111 @@
1+
2+
MOD = int(1e9 + 7)
3+
4+
5+
class SegmentTree:
6+
def __init__(self, l, r):
7+
self.l = l
8+
self.r = r
9+
self.v = 0
10+
self.left = None
11+
self.right = None
12+
self.add = 0
13+
self.mul = 1
14+
15+
@property
16+
def mid(self):
17+
return (self.l + self.r) >> 1
18+
19+
@property
20+
def _left(self):
21+
if self.left is None:
22+
self.left = SegmentTree(self.l, self.mid)
23+
return self.left
24+
25+
@property
26+
def _right(self):
27+
if self.right is None:
28+
self.right = SegmentTree(self.mid + 1, self.r)
29+
return self.right
30+
31+
def pushup(self):
32+
self.v = self._left.v + self._right.v
33+
self.v %= MOD
34+
35+
def modify_add(self, l, r, inc):
36+
if self.l >= l and self.r <= r:
37+
self.v = (self.v + (self.r - self.l + 1) * inc) % MOD
38+
self.add += inc
39+
return
40+
self.pushdown()
41+
if l <= self.mid:
42+
self._left.modify_add(l, r, inc)
43+
if r > self.mid:
44+
self._right.modify_add(l, r, inc)
45+
self.pushup()
46+
47+
def modify_mul(self, l, r, m):
48+
if self.l >= l and self.r <= r:
49+
self.v = (self.v * m) % MOD
50+
self.add = (self.add * m) % MOD
51+
self.mul = (self.mul * m) % MOD
52+
return
53+
self.pushdown()
54+
if l <= self.mid:
55+
self._left.modify_mul(l, r, m)
56+
if r > self.mid:
57+
self._right.modify_mul(l, r, m)
58+
self.pushup()
59+
60+
def query(self, l, r):
61+
if self.l >= l and self.r <= r:
62+
return self.v
63+
self.pushdown()
64+
v = 0
65+
if l <= self.mid:
66+
v += self._left.query(l, r)
67+
if r > self.mid:
68+
v += self._right.query(l, r)
69+
return v % MOD
70+
71+
def pushdown(self):
72+
left, right = self._left, self._right
73+
if self.add or self.mul != 1:
74+
left.v = (left.v * self.mul +
75+
(left.r - left.l + 1) * self.add) % MOD
76+
right.v = (right.v * self.mul +
77+
(right.r - right.l + 1) * self.add) % MOD
78+
left.add = (left.add * self.mul + self.add) % MOD
79+
right.add = (right.add * self.mul + self.add) % MOD
80+
left.mul = (left.mul * self.mul) % MOD
81+
right.mul = (right.mul * self.mul) % MOD
82+
self.add = 0
83+
self.mul = 1
84+
85+
86+
class Fancy:
87+
88+
def __init__(self):
89+
self.n = 0
90+
self.tree = SegmentTree(0, 10**5 + 1)
91+
92+
def append(self, val: int) -> None:
93+
self.n += 1
94+
self.tree.modify_add(self.n, self.n, val)
95+
96+
def addAll(self, inc: int) -> None:
97+
self.tree.modify_add(1, self.n, inc)
98+
99+
def multAll(self, m: int) -> None:
100+
self.tree.modify_mul(1, self.n, m)
101+
102+
def getIndex(self, idx: int) -> int:
103+
return -1 if idx >= self.n else self.tree.query(idx + 1, idx + 1)
104+
105+
106+
# Your Fancy object will be instantiated and called as such:
107+
# obj = Fancy()
108+
# obj.append(val)
109+
# obj.addAll(inc)
110+
# obj.multAll(m)
111+
# param_4 = obj.getIndex(idx)

0 commit comments

Comments
 (0)