Tue, 09 Apr 2019 09:45:35 GMT
parent
f5ee9f7012
commit
9e411fd713
@ -0,0 +1,24 @@
|
||||
#include <bits/stdc++.h>
|
||||
using namespace std;
|
||||
using ll = long long;
|
||||
ll mod = 1e9 + 7;
|
||||
ll qpow(ll a, ll b)
|
||||
{
|
||||
ll ans = 1;
|
||||
for (; b; b >>= 1, a = a * a % mod)
|
||||
if (b & 1)
|
||||
ans = ans * a % mod;
|
||||
return ans;
|
||||
}
|
||||
ll inv(ll x) { return qpow(x, mod - 2); }
|
||||
int main()
|
||||
{
|
||||
ios::sync_with_stdio(false), cin.tie(nullptr);
|
||||
ll T, n, m;
|
||||
cin >> T;
|
||||
while (T--)
|
||||
{
|
||||
cin >> n >> m;
|
||||
cout << (qpow(qpow(2, n) - 1, m - 1) * 2 + (n & 1)) * inv(3) % mod << endl;
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,7 @@
|
||||
cmake_minimum_required(VERSION 3.0)
|
||||
set(CMAKE_CXX_STANDARD 11)
|
||||
include_directories("C:\\Programs\\MSYS2\\mingw64\\include\\c++\\8.3.0\\x86_64-w64-mingw32")
|
||||
add_executable(I I.cpp)
|
||||
add_executable(G G.cpp)
|
||||
add_executable(C C.cpp)
|
||||
add_executable(H H.cpp)
|
||||
@ -0,0 +1,61 @@
|
||||
#include <bits/stdc++.h>
|
||||
using namespace std;
|
||||
const int N = 80000 + 30;
|
||||
char a[N], b[N];
|
||||
int main()
|
||||
{
|
||||
int t, n, x, y;
|
||||
scanf("%d", &t);
|
||||
while (t--)
|
||||
{
|
||||
scanf("%d%d%d%s%s", &n, &x, &y, a, b);
|
||||
int cnt[] = {0, 0};
|
||||
for (int i = 0; i < n; i++)
|
||||
cnt[a[i] != b[i]]++;
|
||||
puts((abs(x - y) > cnt[1]) || (x + y > 2 * n - cnt[1]) ? "Lying" : "Not lying");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
/*
|
||||
#include<bits/stdc++.h>
|
||||
using namespace std;
|
||||
const int MAXN=80000+30;
|
||||
int a[MAXN],b[MAXN];
|
||||
int main(){
|
||||
int t;
|
||||
scanf("%d",&t);
|
||||
while(t--){
|
||||
int n,x,y;
|
||||
char ch;
|
||||
scanf("%d%d%d",&n,&x,&y);
|
||||
getchar();
|
||||
for(int i=0;i<n;i++){
|
||||
scanf("%c",&ch);
|
||||
a[i]=ch-'A';
|
||||
}
|
||||
getchar();
|
||||
for(int i=0;i<n;i++){
|
||||
scanf("%c",&ch);
|
||||
b[i]=ch-'A';
|
||||
}
|
||||
int cnts=0,cntd=0;
|
||||
for(int i=0;i<n;i++){
|
||||
if(a[i]==b[i]){
|
||||
cnts++;
|
||||
}
|
||||
else{
|
||||
cntd++;
|
||||
}
|
||||
}
|
||||
int flag=1;
|
||||
if(abs(x-y)>cntd) flag=0;
|
||||
if(x+y>2*n-cntd) flag=0; //
|
||||
if(flag){
|
||||
printf("Not lying\n");
|
||||
}
|
||||
else{
|
||||
printf("Lying\n");
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}*/
|
||||
@ -0,0 +1,71 @@
|
||||
#include <bits/stdc++.h>
|
||||
using namespace std;
|
||||
const int N = 100100;
|
||||
char s[N];
|
||||
int cnt[26][N];
|
||||
const long long mod = 1e9 + 7;
|
||||
int main()
|
||||
{
|
||||
for (int n, t = 1; ~scanf("%d", &n); t++)
|
||||
{
|
||||
memset(cnt, 0, sizeof(cnt));
|
||||
int maxlen = 0;
|
||||
bool vis[26] = {false};
|
||||
bool vis2[26] = {false};
|
||||
for (int _ = 0; _ < n; _++)
|
||||
{
|
||||
scanf("%s", s);
|
||||
vis2[*s - 'a'] = true;
|
||||
int len = strlen(s);
|
||||
maxlen = max(len, maxlen);
|
||||
for (int i = 0; i < len; i++)
|
||||
cnt[s[len - i - 1] - 'a'][i]++, vis[s[len - i - 1] - 'a'] = true;
|
||||
}
|
||||
set<char> S;
|
||||
for (int i = 0; i < 26; i++)
|
||||
if (vis[i] && !vis2[i])
|
||||
S.insert(i + 'a');
|
||||
maxlen += 10;
|
||||
for (auto &i : cnt)
|
||||
for (int j = 0, *arr = i; j < maxlen; j++)
|
||||
arr[j + 1] += arr[j] / 26, arr[j] %= 26;
|
||||
/*for (int i = 0; i < 26; i++)
|
||||
{
|
||||
printf("%c", 'a' + i);
|
||||
for (int j = 0; j < maxlen; j++)
|
||||
printf(" %d", cnt[i][j]);
|
||||
putchar('\n');
|
||||
}*/
|
||||
pair<char, int *> res[26];
|
||||
for (int i = 0; i < 26; i++)
|
||||
res[i] = make_pair('a' + i, cnt[i]);
|
||||
sort(res, res + 26, [maxlen](const pair<char, int *> &lhs, const pair<char, int *> &rhs) {
|
||||
for (int i = maxlen; i >= 0; i--)
|
||||
{
|
||||
if (lhs.second[i] < rhs.second[i]) return true;
|
||||
if (lhs.second[i] > rhs.second[i]) return false;
|
||||
}
|
||||
return false;
|
||||
});
|
||||
if (vis2[res[0].first - 'a'])
|
||||
for (auto &re : res)
|
||||
if (S.count(re.first))
|
||||
{
|
||||
swap(res[0], re);
|
||||
break;
|
||||
}
|
||||
/*for (auto &re : res)
|
||||
{
|
||||
printf("%c ", re.first);
|
||||
for (int j = 0; j < maxlen; j++)
|
||||
printf("%d ", re.second[j]);
|
||||
putchar('\n');
|
||||
}*/
|
||||
long long ans = 0, base = 1;
|
||||
for (int i = 0; i < maxlen; i++, base = base * 26 % mod)
|
||||
for (int j = 0; j < 26; j++, ans %= mod)
|
||||
ans += j * base * res[j].second[i];
|
||||
printf("Case #%d: %lld\n", t, ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
@ -0,0 +1,29 @@
|
||||
#include <bits/stdc++.h>
|
||||
using namespace std;
|
||||
int main()
|
||||
{
|
||||
long long n, k, t = 0, ans;
|
||||
while (~scanf("%lld%lld", &n, &k))
|
||||
{
|
||||
if (k <= n)
|
||||
ans = k;
|
||||
else
|
||||
{
|
||||
k -= n--;
|
||||
ans = k % n;
|
||||
if (ans == 0)
|
||||
ans = n + 1 - ((k / n) & 1);
|
||||
}
|
||||
printf("Case #%lld: %lld\n", ++t, ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
/*
|
||||
* 1 2 3
|
||||
* 1 2 1 3
|
||||
* 1 2 1 3
|
||||
1 2 3 4 5 6 7
|
||||
1 2 3 4 5 6 1 2 3 4 5 7
|
||||
1 2 3 4 5 6 1 2 3 4 5 7
|
||||
|
||||
*/
|
||||
@ -0,0 +1,57 @@
|
||||
#define _CRT_SECURE_NO_WARNINGS
|
||||
#define _SILENCE_CXX17_C_HEADER_DEPRECATION_WARNING
|
||||
#include <bits/stdc++.h>
|
||||
using namespace std;
|
||||
inline void setBit(int &x, int p) { x |= (1 << p); }
|
||||
inline int getBit(int x, int p) { return x >> p & 1; }
|
||||
inline void flipBit(int &x, int p) { x ^= (1 << p); }
|
||||
const int N = 105;
|
||||
int dis[1 << 20 | 1];
|
||||
bool inq[1 << 20 | 1];
|
||||
int b1[N], b2[N], f1[N], f2[N], t[N];
|
||||
int main()
|
||||
{
|
||||
int n, m, mask;
|
||||
scanf("%d%d", &n, &m);
|
||||
mask = (1 << n) - 1;
|
||||
for (int i = 0; i < m; i++)
|
||||
{
|
||||
char buf1[N], buf2[N];
|
||||
scanf("%d%s%s", t + i, buf1, buf2);
|
||||
for (int k = 0; k < n; k++)
|
||||
{
|
||||
if (buf1[k] == '+') setBit(b1[i], k);
|
||||
if (buf1[k] == '-') setBit(b2[i], k);
|
||||
}
|
||||
for (int k = 0; k < n; k++)
|
||||
{
|
||||
if (buf2[k] == '-') setBit(f1[i], k);
|
||||
if (buf2[k] == '+') setBit(f2[i], k);
|
||||
}
|
||||
}
|
||||
memset(dis, 0x3f, sizeof(dis));
|
||||
queue<int> Q;
|
||||
Q.push(mask);
|
||||
dis[mask] = 0;
|
||||
for (int cur; !Q.empty(); Q.pop())
|
||||
{
|
||||
inq[cur = Q.front()] = false;
|
||||
for (int i = 0; i < m; i++)
|
||||
if ((cur & b1[i]) == b1[i] && (cur & b2[i]) == 0)
|
||||
{
|
||||
int nxt = (cur & ~f1[i]) | f2[i];
|
||||
if (dis[nxt] > dis[cur] + t[i])
|
||||
{
|
||||
dis[nxt] = dis[cur] + t[i];
|
||||
if (!inq[nxt])
|
||||
{
|
||||
inq[nxt] = true;
|
||||
Q.push(nxt);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
if (dis[0] > 0x3f3f3f3f >> 1) dis[0] = 0;
|
||||
printf("%d", dis[0]);
|
||||
return 0;
|
||||
}
|
||||
@ -1,8 +1,34 @@
|
||||
#define _CRT_SECURE_NO_WARNINGS
|
||||
#define _SILENCE_CXX17_C_HEADER_DEPRECATION_WARNING
|
||||
#include <bits/stdc++.h>
|
||||
using namespace std;
|
||||
#include <algorithm>
|
||||
#include <cctype>
|
||||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <numeric>
|
||||
typedef long long int64;
|
||||
template <typename T>
|
||||
inline void readInt(T &x)
|
||||
{
|
||||
int ch = x = 0;
|
||||
while (!isdigit(ch = getchar()))
|
||||
;
|
||||
for (; isdigit(ch); ch = getchar()) x = x * 10 + ch - '0';
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int n;
|
||||
readInt(n);
|
||||
auto *A = new int64[n + 10], *C = new int64[n + 10];
|
||||
memset(A, 0, sizeof(int64) * (n + 10));
|
||||
memset(C, 0, sizeof(int64) * (n + 10));
|
||||
for (int i = 0; i < n; i++) readInt(A[i]);
|
||||
int64 tmp = std::accumulate(A, A + n, 0ll) / n;
|
||||
for (int i = 1; i < n; i++)
|
||||
C[i] = C[i - 1] + tmp - A[i];
|
||||
std::nth_element(C, C + (n >> 1), C + n);
|
||||
tmp = 0;
|
||||
for (int i = 0; i < n; i++)
|
||||
tmp += std::abs(C[i] - C[n >> 1]);
|
||||
printf("%lld", tmp);
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,13 @@
|
||||
cmake_minimum_required(VERSION 3.0)
|
||||
set(CMAKE_CXX_STANDARD 17)
|
||||
if(MSVC)
|
||||
add_compile_options("/Zc:__cplusplus")
|
||||
endif()
|
||||
include_directories("C:\\Programs\\MSYS2\\mingw64\\include\\c++\\8.3.0\\x86_64-w64-mingw32")
|
||||
add_executable(P1 P1.cpp)
|
||||
add_executable(P2 P2.cpp)
|
||||
add_executable(P3 P3.cpp)
|
||||
add_executable(P4 P4.cpp)
|
||||
add_executable(P5 P5.cpp)
|
||||
add_executable(P6 P6.cpp)
|
||||
add_executable(P7 P7.cpp)
|
||||
@ -0,0 +1,32 @@
|
||||
#define _CRT_SECURE_NO_WARNINGS
|
||||
#define _SILENCE_CXX17_C_HEADER_DEPRECATION_WARNING
|
||||
#include <bits/stdc++.h>
|
||||
using namespace std;
|
||||
const int N = 3e5 + 50;
|
||||
int a[N];
|
||||
int main()
|
||||
{
|
||||
int n;
|
||||
scanf("%d", &n);
|
||||
for (int i = 0; i < n; i++)
|
||||
scanf("%d", a + i);
|
||||
map<int, pair<int, int>> M;
|
||||
for (int i = 0; i < n; i++)
|
||||
{
|
||||
if (M.count(a[i]))
|
||||
M[a[i]].second = i;
|
||||
else
|
||||
M[a[i]] = make_pair(i, i);
|
||||
}
|
||||
int ans = 0;
|
||||
set<int> S;
|
||||
for (int i = 0; i < n; i++) S.insert(M[a[i]].second);
|
||||
for (int i = 0; i < n; i++)
|
||||
{
|
||||
S.erase(M[a[i]].second);
|
||||
ans = max(ans, *S.rbegin() - i);
|
||||
S.insert(M[a[i]].second);
|
||||
}
|
||||
printf("%d", ans);
|
||||
return 0;
|
||||
}
|
||||
@ -0,0 +1,50 @@
|
||||
#define _CRT_SECURE_NO_WARNINGS
|
||||
#define _SILENCE_CXX17_C_HEADER_DEPRECATION_WARNING
|
||||
#include <bits/stdc++.h>
|
||||
using namespace std;
|
||||
const int maxn = 1e3 + 50;
|
||||
long long a[maxn];
|
||||
long long txm[maxn];
|
||||
long long n, k;
|
||||
bool test(long long mayk)
|
||||
{
|
||||
memcpy(txm, a, sizeof(a));
|
||||
sort(txm + 1, txm + 1 + mayk);
|
||||
long long nowmax = 0;
|
||||
bool fl = 0;
|
||||
if (mayk & 1) fl = 1;
|
||||
// cout<<mayk<<endl;
|
||||
// cout<<txm[1]<<txm[2]<<txm[3]<<txm[4]<<txm[5]<<endl;
|
||||
for (int i = mayk; i >= 1; i -= 2)
|
||||
{
|
||||
if (i == 1 && fl == 1) break;
|
||||
long long q1 = txm[i], q2 = txm[i + 1];
|
||||
nowmax = max(nowmax + q1, nowmax + q2);
|
||||
if (nowmax > k) return false;
|
||||
}
|
||||
if (fl)
|
||||
{
|
||||
if (nowmax + txm[1] > k) return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
scanf("%lld%lld", &n, &k);
|
||||
for (int i = 1; i <= n; i++)
|
||||
{
|
||||
scanf("%lld", &a[i]);
|
||||
}
|
||||
long long l = 0, r = n + 1;
|
||||
long long mid = (l + r) / 2;
|
||||
while (l + 1 < r)
|
||||
{
|
||||
mid = (l + r) / 2;
|
||||
if (test(mid))
|
||||
l = mid;
|
||||
else
|
||||
r = mid;
|
||||
}
|
||||
printf("%lld\n", l);
|
||||
return 0;
|
||||
}
|
||||
@ -0,0 +1,31 @@
|
||||
#define _CRT_SECURE_NO_WARNINGS
|
||||
#define _SILENCE_CXX17_C_HEADER_DEPRECATION_WARNING
|
||||
#include <bits/stdc++.h>
|
||||
using namespace std;
|
||||
const int N = 505;
|
||||
int a[N][N];
|
||||
int main()
|
||||
{
|
||||
int n, m;
|
||||
scanf("%d%d", &n, &m);
|
||||
for (int _ = 0, x; _ < 2; _++)
|
||||
for (int i = 0; i < n; i++)
|
||||
for (int j = 0; j < m; j++)
|
||||
scanf("%d", &x), a[i][j] ^= x;
|
||||
for (int i = 1; i < n; i++)
|
||||
for (int j = 1; j < m; j++)
|
||||
if (a[i][j])
|
||||
{
|
||||
a[0][0] ^= 1;
|
||||
a[i][0] ^= 1;
|
||||
a[0][j] ^= 1;
|
||||
a[i][j] ^= 1;
|
||||
}
|
||||
int cnt = 0;
|
||||
for (int i = 0; i < n; i++)
|
||||
cnt += a[i][0];
|
||||
for (int j = 0; j < n; j++)
|
||||
cnt += a[0][j];
|
||||
puts(cnt ? "No" : "Yes");
|
||||
return 0;
|
||||
}
|
||||
@ -0,0 +1,36 @@
|
||||
#define _CRT_SECURE_NO_WARNINGS
|
||||
#define _SILENCE_CXX17_C_HEADER_DEPRECATION_WARNING
|
||||
#include <bits/stdc++.h>
|
||||
using namespace std;
|
||||
const int N = 1e5 + 50;
|
||||
using ull = unsigned long long;
|
||||
ull s[N];
|
||||
pair<ull, ull> ps[N];
|
||||
int main()
|
||||
{
|
||||
ios::sync_with_stdio(false);
|
||||
int n, q;
|
||||
cin >> n;
|
||||
for (int i = 0; i < n; i++) cin >> s[i];
|
||||
sort(s, s + n);
|
||||
n = unique(s, s + n) - s;
|
||||
cin >> q;
|
||||
while (q--)
|
||||
{
|
||||
ull L, R, ans = 0;
|
||||
cin >> L >> R;
|
||||
//R -= L, L = 0;
|
||||
for (int i = 0; i < n; i++) ps[i] = make_pair(s[i] + L, s[i] + R);
|
||||
for (int i = 1; i < n; i++)
|
||||
if (ps[i - 1].second >= ps[i].first)
|
||||
{
|
||||
ps[i].first = ps[i - 1].first;
|
||||
ps[i - 1] = make_pair(0, 0);
|
||||
}
|
||||
for (int i = 0; i < n; i++)
|
||||
if (ps[i].first | ps[i].second)
|
||||
ans += ps[i].second - ps[i].first + 1;
|
||||
cout << ans << " ";
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
@ -0,0 +1,8 @@
|
||||
#define _CRT_SECURE_NO_WARNINGS
|
||||
#define _SILENCE_CXX17_C_HEADER_DEPRECATION_WARNING
|
||||
#include <bits/stdc++.h>
|
||||
using namespace std;
|
||||
int main()
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
@ -0,0 +1,8 @@
|
||||
#define _CRT_SECURE_NO_WARNINGS
|
||||
#define _SILENCE_CXX17_C_HEADER_DEPRECATION_WARNING
|
||||
#include <bits/stdc++.h>
|
||||
using namespace std;
|
||||
int main()
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
@ -0,0 +1,8 @@
|
||||
#define _CRT_SECURE_NO_WARNINGS
|
||||
#define _SILENCE_CXX17_C_HEADER_DEPRECATION_WARNING
|
||||
#include <bits/stdc++.h>
|
||||
using namespace std;
|
||||
int main()
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
@ -0,0 +1,19 @@
|
||||
cmake_minimum_required(VERSION 3.0)
|
||||
set(CMAKE_CXX_STANDARD 17)
|
||||
if(MSVC)
|
||||
add_compile_options("/Zc:__cplusplus")
|
||||
endif()
|
||||
include_directories("C:\\Programs\\MSYS2\\mingw64\\include\\c++\\8.3.0\\x86_64-w64-mingw32")
|
||||
add_executable(P01 P01.cpp)
|
||||
add_executable(P02 P02.cpp)
|
||||
add_executable(P03 P03.cpp)
|
||||
add_executable(P04 P04.cpp)
|
||||
add_executable(P05 P05.cpp)
|
||||
add_executable(P06 P06.cpp)
|
||||
add_executable(P07 P07.cpp)
|
||||
add_executable(P08 P08.cpp)
|
||||
add_executable(P09 P09.cpp)
|
||||
add_executable(P10 P10.cpp)
|
||||
add_executable(P11 P11.cpp)
|
||||
add_executable(P12 P12.cpp)
|
||||
add_executable(P13 P13.cpp)
|
||||
@ -0,0 +1,26 @@
|
||||
#define _CRT_SECURE_NO_WARNINGS
|
||||
#define _SILENCE_CXX17_C_HEADER_DEPRECATION_WARNING
|
||||
#include <bits/stdc++.h>
|
||||
using namespace std;
|
||||
struct Point
|
||||
{
|
||||
double x, y;
|
||||
};
|
||||
double dis(Point x, Point y) { return sqrt((x.x - y.x) * (x.x - y.x) + (x.y - y.y) * (x.y - y.y)); }
|
||||
double cos(double a, double b, double c) { return (b * b + c * c - a * a) / (2 * b * c); }
|
||||
double dis(Point x, Point a, Point b)
|
||||
{
|
||||
double l1 = dis(x, a);
|
||||
double l2 = dis(x, b);
|
||||
double l3 = dis(a, b);
|
||||
if (cos(l1, l2, l3) < 0) return l2;
|
||||
if (cos(l2, l1, l3) < 0) return l1;
|
||||
double p = (l1 + l2 + l3) / 2;
|
||||
double area = sqrt(p * (p - l1) * (p - l2) * (p - l3));
|
||||
return area * 2 / l3;
|
||||
}
|
||||
double dis(double x, Point a, Point b) { return dis({x, 0}, a, b); }
|
||||
int main()
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
@ -0,0 +1,25 @@
|
||||
#define _CRT_SECURE_NO_WARNINGS
|
||||
#define _SILENCE_CXX17_C_HEADER_DEPRECATION_WARNING
|
||||
#include <bits/stdc++.h>
|
||||
using namespace std;
|
||||
int dx[] = {0, 1, 0, -1};
|
||||
int dy[] = {1, 0, -1, 0};
|
||||
int main()
|
||||
{
|
||||
ios::sync_with_stdio(false);
|
||||
int T, n;
|
||||
cin >> T;
|
||||
for (int t = 1; t <= T; t++)
|
||||
{
|
||||
cin >> n;
|
||||
long long x = 0, y = 0, l;
|
||||
for (int i = 0; i < n; i++)
|
||||
{
|
||||
cin >> l;
|
||||
x += dx[i & 3] * l;
|
||||
y += dy[i & 3] * l;
|
||||
}
|
||||
cout << "Case #" << t << ':' << x * x + y * y << endl;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
@ -0,0 +1,47 @@
|
||||
#define _CRT_SECURE_NO_WARNINGS
|
||||
#define _SILENCE_CXX17_C_HEADER_DEPRECATION_WARNING
|
||||
#include <bits/stdc++.h>
|
||||
using namespace std;
|
||||
inline int lowbit(int x) { return x & -x; }
|
||||
const int N = 2e5 + 50;
|
||||
set<unsigned> C[N];
|
||||
int OP[N], X[N], Y[N], H[N];
|
||||
void add(unsigned x, unsigned y)
|
||||
{
|
||||
for (; x < N; x += lowbit(x))
|
||||
C[x].insert(y);
|
||||
}
|
||||
unsigned query(unsigned x, unsigned y)
|
||||
{
|
||||
unsigned ans = -1;
|
||||
for (; x; x -= lowbit(x))
|
||||
{
|
||||
auto ite = C[x].lower_bound(y);
|
||||
if (ite != C[x].end())
|
||||
ans = min(ans, *ite);
|
||||
}
|
||||
return ans;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int N, Q;
|
||||
char op[3];
|
||||
scanf("%d%d", &N, &Q);
|
||||
for (int i = 0; i < Q; i++)
|
||||
{
|
||||
scanf("%s%d%d", op, X + i, Y + i);
|
||||
OP[i] = (*op == 'D');
|
||||
}
|
||||
memcpy(H, X, sizeof(X));
|
||||
sort(H, H + Q);
|
||||
auto len = unique(H, H + Q) - H;
|
||||
for (int i = 0; i < Q; i++) X[i] = lower_bound(H, H + len, X[i]) - H + 1;
|
||||
for (int i = 0; i < Q; i++)
|
||||
{
|
||||
if (OP[i] == 0)
|
||||
add(X[i], Y[i]);
|
||||
if (OP[i] == 1)
|
||||
printf("%d\n", query(X[i], Y[i]));
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
@ -0,0 +1,36 @@
|
||||
#define _CRT_SECURE_NO_WARNINGS
|
||||
#define _SILENCE_CXX17_C_HEADER_DEPRECATION_WARNING
|
||||
#include <bits/stdc++.h>
|
||||
using namespace std;
|
||||
const int N = 2e5 + 50;
|
||||
using ll = long long;
|
||||
ll fac[N];
|
||||
ll mod = 1e9 + 7;
|
||||
ll qpow(ll a, ll b)
|
||||
{
|
||||
ll ans = 1;
|
||||
for (; b; b >>= 1, a = a * a % mod)
|
||||
if (b & 1)
|
||||
ans = ans * a % mod;
|
||||
return ans;
|
||||
}
|
||||
ll inv(ll x) { return qpow(x, mod - 2); }
|
||||
ll C(ll n, ll m)
|
||||
{
|
||||
if (m > n || m < 0) return 0;
|
||||
return fac[n] * inv(fac[n - m] * fac[m] % mod) % mod;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
fac[0] = 1;
|
||||
for (int i = 1; i < N; i++) fac[i] = fac[i - 1] * i % mod;
|
||||
int T;
|
||||
cin >> T;
|
||||
while (T--)
|
||||
{
|
||||
long long m, n;
|
||||
cin >> m >> n;
|
||||
cout << ((C(n + m, m) - (C(n + m - 1, m - 1) * 2) % mod + mod) % mod) << endl;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
@ -0,0 +1,35 @@
|
||||
#define _CRT_SECURE_NO_WARNINGS
|
||||
#define _SILENCE_CXX17_C_HEADER_DEPRECATION_WARNING
|
||||
#include <bits/stdc++.h>
|
||||
using namespace std;
|
||||
int main()
|
||||
{
|
||||
ios::sync_with_stdio(false);
|
||||
int T, n;
|
||||
cin >> T;
|
||||
map<char, set<char>> mp;
|
||||
mp['2'].insert({'a', 'b', 'c'});
|
||||
mp['3'].insert({'d', 'e', 'f'});
|
||||
mp['4'].insert({'g', 'h', 'i'});
|
||||
mp['5'].insert({'j', 'k', 'l'});
|
||||
mp['6'].insert({'m', 'n', 'o'});
|
||||
mp['7'].insert({'p', 'q', 'r', 's'});
|
||||
mp['8'].insert({'t', 'u', 'v'});
|
||||
mp['9'].insert({'w', 'x', 'y', 'z'});
|
||||
for (int t = 1; t <= T; t++)
|
||||
{
|
||||
cout << "Case #" << t << ":\n";
|
||||
string num, chk;
|
||||
cin >> num >> n;
|
||||
while (n--)
|
||||
{
|
||||
cin >> chk;
|
||||
bool flag = true;
|
||||
for (size_t i = 0; i < num.size(); i++)
|
||||
if (mp[num[i]].count(chk[i]) == 0)
|
||||
flag = false;
|
||||
cout << (flag ? "Maybe.." : "How could that be possible?") << endl;
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
@ -0,0 +1,266 @@
|
||||
#define _CRT_SECURE_NO_WARNINGS
|
||||
#define _SILENCE_CXX17_C_HEADER_DEPRECATION_WARNING
|
||||
#include <bits/stdc++.h>
|
||||
using namespace std;
|
||||
const int N = 2e5 + 5;
|
||||
#define cls(x) memset(x, 0, sizeof(x))
|
||||
struct point
|
||||
{
|
||||
int l, r, w;
|
||||
} c[N * 30];
|
||||
int fa[N][25], a[N], h[N], tot, num, deep[N], n, m, rt[N], xxx, val[N];
|
||||
int nxt[N << 1], head[N], go[N << 1];
|
||||
inline int read()
|
||||
{
|
||||
int x;
|
||||
scanf("%d", &x);
|
||||
return x;
|
||||
}
|
||||
inline void insert(int y, int &x, int l, int r, int p)
|
||||
{
|
||||
c[x = ++num] = c[y];
|
||||
c[x].w++;
|
||||
if (l == r) return;
|
||||
int mid = (l + r) >> 1;
|
||||
if (p <= mid)
|
||||
insert(c[y].l, c[x].l, l, mid, p);
|
||||
else
|
||||
insert(c[y].r, c[x].r, mid + 1, r, p);
|
||||
c[x].w = c[c[x].l].w + c[c[x].r].w;
|
||||
}
|
||||
inline int query(int x, int y, int z, int d, int l, int r, int k)
|
||||
{
|
||||
if (l == r) return l;
|
||||
int ret = c[c[x].l].w + c[c[y].l].w - c[c[z].l].w - c[c[d].l].w;
|
||||
int mid = (l + r) >> 1;
|
||||
if (k <= ret)
|
||||
return query(c[x].l, c[y].l, c[z].l, c[d].l, l, mid, k);
|
||||
else
|
||||
return query(c[x].r, c[y].r, c[z].r, c[d].r, mid + 1, r, k - ret);
|
||||
}
|
||||
inline void add(int x, int y)
|
||||
{
|
||||
nxt[++tot] = head[x];
|
||||
head[x] = tot;
|
||||
go[tot] = y;
|
||||
nxt[++tot] = head[y];
|
||||
head[y] = tot;
|
||||
go[tot] = x;
|
||||
}
|
||||
inline void dfs2(int u)
|
||||
{
|
||||
insert(rt[fa[u][0]], rt[u], 1, n, val[u]);
|
||||
for (int i = head[u]; i; i = nxt[i])
|
||||
{
|
||||
int v = go[i];
|
||||
if (v == fa[u][0]) continue;
|
||||
dfs2(v);
|
||||
}
|
||||
}
|
||||
inline void dfs(int u, int father)
|
||||
{
|
||||
deep[u] = deep[father] + 1;
|
||||
for (int i = 0; i <= 20; i++)
|
||||
fa[u][i + 1] = fa[fa[u][i]][i];
|
||||
for (int i = head[u]; i; i = nxt[i])
|
||||
{
|
||||
int v = go[i];
|
||||
if (v == father) continue;
|
||||
fa[v][0] = u;
|
||||
dfs(v, u);
|
||||
}
|
||||
}
|
||||
inline int lca(int x, int y)
|
||||
{
|
||||
if (deep[x] < deep[y]) swap(x, y);
|
||||
for (int i = 20; i >= 0; i--)
|
||||
{
|
||||
if (deep[fa[x][i]] >= deep[y])
|
||||
x = fa[x][i];
|
||||
if (x == y) return x;
|
||||
}
|
||||
for (int i = 20; i >= 0; i--)
|
||||
{
|
||||
if (fa[x][i] != fa[y][i])
|
||||
{
|
||||
x = fa[x][i];
|
||||
y = fa[y][i];
|
||||
}
|
||||
}
|
||||
return fa[x][0];
|
||||
}
|
||||
inline int find(int x)
|
||||
{
|
||||
int l = 1, r = xxx, mid;
|
||||
while (l <= r)
|
||||
{
|
||||
mid = (l + r) >> 1;
|
||||
if (x > h[mid])
|
||||
l = mid + 1;
|
||||
else
|
||||
r = mid - 1;
|
||||
}
|
||||
return l;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int T = read();
|
||||
while (T--)
|
||||
{
|
||||
/*int fa[N][25], a[N], h[N], tot, num, deep[N], n, m, rt[N], xxx, val[N];
|
||||
int nxt[N << 1], head[N], go[N << 1];*/
|
||||
cls(fa), cls(a), cls(h), cls(deep), cls(rt), cls(val), cls(nxt), cls(head), cls(go);
|
||||
tot = num = 0;
|
||||
int i, j, u, v, k;
|
||||
n = read();
|
||||
m = read();
|
||||
for (i = 1; i <= n; i++)
|
||||
{
|
||||
val[i] = -read();
|
||||
a[i] = val[i];
|
||||
}
|
||||
for (i = 1; i < n; i++)
|
||||
{
|
||||
u = read();
|
||||
v = read();
|
||||
add(u, v);
|
||||
}
|
||||
sort(a + 1, a + n + 1);
|
||||
h[1] = a[1];
|
||||
xxx = 1;
|
||||
for (i = 2; i <= n; i++)
|
||||
if (a[i] != a[i - 1]) h[++xxx] = a[i];
|
||||
for (i = 1; i <= n; i++)
|
||||
val[i] = find(val[i]);
|
||||
dfs(1, 0);
|
||||
int ans = 0;
|
||||
dfs2(1);
|
||||
for (i = 1; i <= m; i++)
|
||||
{
|
||||
u = read();
|
||||
v = read();
|
||||
k = read();
|
||||
int z = lca(u, v);
|
||||
int len = deep[u] - deep[z] + deep[v] - deep[z] + 1;
|
||||
if (k > len)
|
||||
ans = -1;
|
||||
else
|
||||
ans = -h[query(rt[u], rt[v], rt[z], rt[fa[z][0]], 1, n, k)];
|
||||
printf("%d\n", ans);
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
/*#define _CRT_SECURE_NO_WARNINGS
|
||||
#define _SILENCE_CXX17_C_HEADER_DEPRECATION_WARNING
|
||||
#include <bits/stdc++.h>
|
||||
using namespace std;
|
||||
const int N = 100011, NlogN = 2000011;
|
||||
struct Tree
|
||||
{
|
||||
int ls, rs, sum;
|
||||
#define ls(now) (tr[now].ls)
|
||||
#define rs(now) (tr[now].rs)
|
||||
#define sum(now) (tr[now].sum)
|
||||
} tr[NlogN];
|
||||
int rt[N];
|
||||
int n, m, ans, a[N], b[N];
|
||||
int x, y, p, k, cnt;
|
||||
inline void disc_init()
|
||||
{
|
||||
sort(b + 1, b + b[0] + 1);
|
||||
b[0] = unique(b + 1, b + b[0] + 1) - b - 1;
|
||||
for (int i = 1; i <= n; i++)
|
||||
a[i] = lower_bound(b + 1, b + b[0] + 1, a[i]) - b;
|
||||
}
|
||||
struct edge
|
||||
{
|
||||
int to;
|
||||
edge *nxt;
|
||||
#define VIS(now) for (edge *it = las[now]; it; it = it->nxt)
|
||||
#define to(it) (it->to)
|
||||
} e[N << 1], *las[N], *tot = e;
|
||||
int top[N], fa[N], dep[N], sz[N];
|
||||
inline void add(int x, int y)
|
||||
{
|
||||
*++tot = edge{y, las[x]}, las[x] = tot;
|
||||
}
|
||||
inline void dfs1(int now)
|
||||
{
|
||||
int to;
|
||||
sz[now] = 1;
|
||||
VIS(now)
|
||||
if (!dep[to(it)])
|
||||
{
|
||||
dep[to(it)] = dep[now] + 1;
|
||||
fa[to(it)] = now;
|
||||
dfs1(to(it));
|
||||
sz[now] += sz[to(it)];
|
||||
}
|
||||
}
|
||||
inline void build(int cpy, int &now, int l, int r, int pos)
|
||||
{
|
||||
tr[now = ++cnt] = tr[cpy];
|
||||
++sum(now);
|
||||
if (l == r) return;
|
||||
int mid = (l + r) >> 1;
|
||||
pos <= mid ? build(ls(cpy), ls(now), l, mid, pos) : build(rs(cpy), rs(now), mid + 1, r, pos);
|
||||
}
|
||||
inline int query(int a, int b, int c, int d, int l, int r, int k)
|
||||
{
|
||||
if (l == r) return l;
|
||||
int data = sum(ls(a)) + sum(ls(b)) - sum(ls(c)) - sum(ls(d));
|
||||
int mid = (l + r) >> 1;
|
||||
return k <= data ? query(ls(a), ls(b), ls(c), ls(d), l, mid, k) : query(rs(a), rs(b), rs(c), rs(d), mid + 1, r, k - data);
|
||||
}
|
||||
inline void dfs2(int now, int chain)
|
||||
{
|
||||
top[now] = chain;
|
||||
build(rt[fa[now]], rt[now], 1, b[0], a[now]);
|
||||
register int i = 0;
|
||||
VIS(now)
|
||||
if (fa[now] != (to(it)) && sz[to(it)] > sz[i]) i = to(it);
|
||||
if (!i) return;
|
||||
dfs2(i, chain);
|
||||
VIS(now)
|
||||
if (fa[now] != (to(it)) && i != to(it)) dfs2(to(it), to(it));
|
||||
}
|
||||
inline int lca(int x, int y)
|
||||
{
|
||||
for (; top[x] != top[y]; dep[top[x]] > dep[top[y]] ? x = fa[top[x]] : y = fa[top[y]])
|
||||
;
|
||||
return dep[x] < dep[y] ? x : y;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int T;
|
||||
scanf("%d", &T);
|
||||
while (T--)
|
||||
{
|
||||
scanf("%d%d", &n, &m);
|
||||
for (int i = 1; i <= n; i++)
|
||||
scanf("%d", a + i), b[++b[0]] = -a[i];
|
||||
disc_init();
|
||||
for (int i = 2; i <= n; i++)
|
||||
{
|
||||
scanf("%d%d", &x, &y);
|
||||
add(x, y);
|
||||
add(y, x);
|
||||
}
|
||||
dep[1] = 1;
|
||||
dfs1(1);
|
||||
dfs2(1, 1);
|
||||
while (m--)
|
||||
{
|
||||
scanf("%d%d%d", &x, &y, &k);
|
||||
p = lca(x, y);
|
||||
int dis = dep[x] - dep[p] + dep[y] - dep[p] + 1;
|
||||
if (k > dis)
|
||||
ans = -1;
|
||||
else
|
||||
ans = -b[query(rt[x], rt[y], rt[p], rt[fa[p]], 1, b[0], k)];
|
||||
printf("%d\n", ans);
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}*/
|
||||
@ -0,0 +1,8 @@
|
||||
#define _CRT_SECURE_NO_WARNINGS
|
||||
#define _SILENCE_CXX17_C_HEADER_DEPRECATION_WARNING
|
||||
#include <bits/stdc++.h>
|
||||
using namespace std;
|
||||
int main()
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
@ -0,0 +1,8 @@
|
||||
#define _CRT_SECURE_NO_WARNINGS
|
||||
#define _SILENCE_CXX17_C_HEADER_DEPRECATION_WARNING
|
||||
#include <bits/stdc++.h>
|
||||
using namespace std;
|
||||
int main()
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
@ -0,0 +1,8 @@
|
||||
#define _CRT_SECURE_NO_WARNINGS
|
||||
#define _SILENCE_CXX17_C_HEADER_DEPRECATION_WARNING
|
||||
#include <bits/stdc++.h>
|
||||
using namespace std;
|
||||
int main()
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
@ -0,0 +1,8 @@
|
||||
#define _CRT_SECURE_NO_WARNINGS
|
||||
#define _SILENCE_CXX17_C_HEADER_DEPRECATION_WARNING
|
||||
#include <bits/stdc++.h>
|
||||
using namespace std;
|
||||
int main()
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
@ -0,0 +1,8 @@
|
||||
#define _CRT_SECURE_NO_WARNINGS
|
||||
#define _SILENCE_CXX17_C_HEADER_DEPRECATION_WARNING
|
||||
#include <bits/stdc++.h>
|
||||
using namespace std;
|
||||
int main()
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
@ -0,0 +1,8 @@
|
||||
#define _CRT_SECURE_NO_WARNINGS
|
||||
#define _SILENCE_CXX17_C_HEADER_DEPRECATION_WARNING
|
||||
#include <bits/stdc++.h>
|
||||
using namespace std;
|
||||
int main()
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
@ -0,0 +1,8 @@
|
||||
#define _CRT_SECURE_NO_WARNINGS
|
||||
#define _SILENCE_CXX17_C_HEADER_DEPRECATION_WARNING
|
||||
#include <bits/stdc++.h>
|
||||
using namespace std;
|
||||
int main()
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
@ -0,0 +1,67 @@
|
||||
data = [('FloraPrice', 'E11'), ('FloraPrice', 'E9'), ('FloraPrice', '75D}'),
|
||||
('NoraFayette', 'E11'), ('NoraFayette', 'E10'), ('NoraFayette', 'E13'),
|
||||
('NoraFayette', 'E12'), ('NoraFayette', 'E14'), ('NoraFayette', 'E9'),
|
||||
('NoraFayette', 'E7'), ('NoraFayette', 'E6'), ('E10',
|
||||
'SylviaAvondale'),
|
||||
('E10', 'MyraLiddel'), ('E10', 'HelenLloyd'), ('E10',
|
||||
'KatherinaRogers'),
|
||||
('VerneSanderson', 'E7'), ('VerneSanderson', 'E12'),
|
||||
('VerneSanderson', 'E9'), ('VerneSanderson', 'E8'),
|
||||
('E12', 'HelenLloyd'), ('E12', 'KatherinaRogers'),
|
||||
('E12', 'SylviaAvondale'), ('E12', 'MyraLiddel'),
|
||||
('E14', 'SylviaAvondale'), ('E14', '75D}'), ('E14', 'KatherinaRogers'),
|
||||
('FrancesAnderson', 'E5'), ('FrancesAnderson', 'E6'),
|
||||
('FrancesAnderson', 'E8'), ('FrancesAnderson', 'E3'),
|
||||
('DorothyMurchison', 'E9'), ('DorothyMurchison', 'E8'),
|
||||
('EvelynJefferson', 'E9'), ('EvelynJefferson', 'E8'),
|
||||
('EvelynJefferson', 'E5'), ('EvelynJefferson', 'E4'),
|
||||
('EvelynJefferson', 'E6'), ('EvelynJefferson', 'E1'),
|
||||
('EvelynJefferson', 'E3'), ('EvelynJefferson', 'E2'),
|
||||
('RuthDeSand', 'E5'), ('RuthDeSand', 'E7'), ('RuthDeSand', 'E9'),
|
||||
('RuthDeSand', 'E8'), ('HelenLloyd', 'E11'), ('HelenLloyd', 'E7'),
|
||||
('HelenLloyd', 'E8'), ('OliviaCarleton', 'E11'),
|
||||
('OliviaCarleton', 'E9'), ('EleanorNye', 'E5'), ('EleanorNye', 'E7'),
|
||||
('EleanorNye', 'E6'), ('EleanorNye', 'E8'), ('E9', 'TheresaAnderson'),
|
||||
('E9', 'PearlOglethorpe'), ('E9', 'KatherinaRogers'),
|
||||
('E9', 'SylviaAvondale'), ('E9', 'MyraLiddel'),
|
||||
('E8', 'TheresaAnderson'), ('E8', 'PearlOglethorpe'),
|
||||
('E8', 'KatherinaRogers'), ('E8', 'SylviaAvondale'),
|
||||
('E8', 'BrendaRogers'), ('E8', 'LauraMandeville'), ('E8',
|
||||
'MyraLiddel'),
|
||||
('E5', 'TheresaAnderson'), ('E5', 'BrendaRogers'),
|
||||
('E5', 'LauraMandeville'), ('E5', 'CharlotteMcDowd'),
|
||||
('E4', 'CharlotteMcDowd'), ('E4', 'TheresaAnderson'),
|
||||
('E4', 'BrendaRogers'), ('E7', 'TheresaAnderson'),
|
||||
('E7', 'SylviaAvondale'), ('E7', 'BrendaRogers'),
|
||||
('E7', 'LauraMandeville'), ('E7', 'CharlotteMcDowd'),
|
||||
('E6', 'TheresaAnderson'), ('E6', 'PearlOglethorpe'),
|
||||
('E6', 'BrendaRogers'), ('E6', 'LauraMandeville'),
|
||||
('E1', 'LauraMandeville'), ('E1', 'BrendaRogers'),
|
||||
('E3', 'TheresaAnderson'), ('E3', 'BrendaRogers'),
|
||||
('E3', 'LauraMandeville'), ('E3', 'CharlotteMcDowd'), ('E3', 'flag{'),
|
||||
('E2', 'LauraMandeville'), ('E2', 'TheresaAnderson'),
|
||||
('KatherinaRogers', 'E13'), ('E13', 'SylviaAvondale')]
|
||||
from collections import *
|
||||
from typing import *
|
||||
from queue import *
|
||||
edges: Dict[str, List[str]] = defaultdict(list)
|
||||
dis: Dict[str, int] = {}
|
||||
path: Dict[str, str] = defaultdict(str)
|
||||
for f, t in data:
|
||||
edges[f].append(t)
|
||||
edges[t].append(f)
|
||||
dis[f] = dis[t] = 0x3f3f3f3f
|
||||
|
||||
q = Queue()
|
||||
q.put("flag{")
|
||||
dis["flag{"] = 0
|
||||
while not q.empty():
|
||||
x = q.get()
|
||||
print(x)
|
||||
for e in edges[x]:
|
||||
if dis[e] > dis[x] + 1:
|
||||
dis[e] = dis[x] + 1
|
||||
path[e] = path[x] + e
|
||||
q.put(e)
|
||||
|
||||
print(path["75D}"])
|
||||
Loading…
Reference in new issue