Andrew Stankevich's Contest (1)
Andrew Stankevich's Contest (1)
打一半出门了，回来才补完了。。。各种大数又不能上java。。也是蛋疼无比
A：根据置换循环节很容易得出要gcd(x, n) = 1并且x <= n / 2，那么把对应几种情况的最大值考虑一下即可，分别是n % 2 = 1为n / 2, n % 4 = 0为n / 2 - 1，n % 4 = 2为n / 2 - 2
B：限制下限的最大流，建模方法为原来容量变成c - l，然后源点连到每个点的下限和为正，每个点下限和为负连到汇点，跑一下最大流，如果源点流出的全部满流就是有解，然后输出的时候只要把对应的自由流加上下限即可
C：贪心，从叶子结点不断往上推，一有合适就用掉，然后把父结点标记一下用来判断即可
D：就简单的矩阵相乘，由于要考虑复杂度，所以可以先算出没排的和，然后每个位置分别乘上对应那排再累加即可
E：矩阵快速幂，把两两关系确立后，建立矩阵跑一下快速幂即可
F：几何题，判断有限视角和是否会形成-2pi，利用spfa判负环即可
G：LIS，先按x从小到大，再按y从大到小排序，这样对y做lis就是答案，由于要输出路径，所以开一个dp数组记录下每个位置的答案，然后在扫一遍任意输出一种方案即可
H：高斯消元，和大白书上例题差不多，完全平方数的每个因子必然是偶数，这样就可以建立异或方程，然后计算出自由便元个数x，那么答案就是2^x - 1
const int MAXN = 2005;
struct bign {
ll num[MAXN];
memset(num, 0, sizeof(num));
bign (ll number) {*this =}
bign (const char* number) {*this =}
void DelZero ();
void Put ();
void operator = (ll number);
void operator = (char* number);
bool operator
(const bign& b) const { return b < * }
bool operator <= (const bign& b) const { return !(b = (const bign& b) const { return !(*this < b); }
bool operator != (const bign& b) const { return b < *this || *this = 0; i--)
printf("%lld", num[i]);
void bign::operator = (char* number) {
len = strlen (number);
for (int i = 0; i < i++)
num[i] = number[len-i-1] - '0';
DelZero ();
void bign::operator = (ll number) {
while (number) {
num[len++] = number%10;
number /= 10;
DelZero ();
bool bign::operator < (const bign& b) const {
if (len != b.len)
return len = 0; i--)
if (num[i] != b.num[i])
return num[i] < b.num[i];
void bign::operator ++ () {
int s = 1;
for (int i = 0; i < i++) {
s = s + num[i];
num[i] = s % 10;
while (s) {
num[len++] = s%10;
void bign::operator -- () {
if (num[0] == 0 && len == 1)
int s = -1;
for (int i = 0; i = 0)
DelZero ();
bign bign::operator + (const int& b) {
return *this +
bign bign::operator + (const bign& b) {
int bignSum = 0;
for (int i = 0; i < len || i < b. i++) {
if (i < len) bignSum += num[i];
if (i < b.len) bignSum += b.num[i];
ans.num[ans.len++] = bignSum % 10;
bignSum /= 10;
while (bignSum) {
ans.num[ans.len++] = bignSum % 10;
bignSum /= 10;
bign bign::operator - (const int& b) {
return *this -
bign bign::operator - (const bign& b) {
ll bignSub = 0;
for (int i = 0; i < len || i < b. i++) {
bignSub += num[i];
if (i < b.len)
bignSub -= b.num[i];
ans.num[ans.len++] = (bignSub + 10) % 10;
if (bignSub < 0) bignSub = -1;
else bignSub = 0;
ans.DelZero();
bign bign::operator * (const ll& b) {
ll bignSum = 0;
for (int i = 0; i < i++) {
bignSum += num[i] *
ans.num[i] = bignSum % 10;
bignSum /= 10;
while (bignSum) {
ans.num[ans.len++] = bignSum % 10;
bignSum /= 10;
bign bign::operator * (const bign& b) {
ans.len = 0;
for (int i = 0; i < i++){
int bignSum = 0;
for (int j = 0; j = 0; i--) {
s = s * 10 + num[i];
ans.num[i] = s/b;
ans.DelZero();
int bign::operator % (const int& b) {
int s = 0;
for (int i = len-1; i >= 0; i--) {
s = s * 10 + num[i];
ans.num[i] = s/b;
const int MAXNODE = 205;
const int MAXEDGE = 210005;
typedef int T
const Type INF = 0x3f3f3f3f;
struct Edge {
Type cap, flow,
Edge(int u, int v, Type cap, Type flow, Type low) {
this->cap =
this->flow =
this->low =
struct Dinic {
int n, m, s,
Edge edges[MAXEDGE];
int first[MAXNODE];
int next[MAXEDGE];
bool vis[MAXNODE];
Type d[MAXNODE];
int cur[MAXNODE];
void init(int n) {
memset(first, -1, sizeof(first));
void add_Edge(int u, int v, Type cap, Type low) {
edges[m] = Edge(u, v, cap, 0, low);
next[m] = first[u];
first[u] = m++;
edges[m] = Edge(v, u, 0, 0, low);
next[m] = first[v];
first[v] = m++;
bool bfs() {
memset(vis, false, sizeof(vis));
Q.push(s);
while (!Q.empty()) {
int u = Q.front(); Q.pop();
for (int i = first[u]; i != -1; i = next[i]) {
Edge& e = edges[i];
if (!vis[e.v] && e.cap > e.flow) {
vis[e.v] =
d[e.v] = d[u] + 1;
Q.push(e.v);
return vis[t];
Type dfs(int u, Type a) {
if (u == t || a == 0)
Type flow = 0,
for (int &i = cur[u]; i != -1; i = next[i]) {
Edge& e = edges[i];
if (d[u] + 1 == d[e.v] && (f = dfs(e.v, min(a, e.cap - e.flow))) > 0) {
edges[i^1].flow -=
if (a == 0)
Type Maxflow(int s, int t) {
this->s = this->t =
Type flow = 0;
while (bfs()) {
for (int i = 0; i < i++)
cur[i] = first[i];
flow += dfs(s, INF);
bool solve(int s, int t, int tot) {
Maxflow(s, t);
for (int i = first[s]; i + 1; i = next[i]) {
if (edges[i].flow != edges[i].cap)
printf("YES\n");
for (int i = 0; i < 2 * i += 2)
printf("%d\n", edges[i].flow + edges[i].low);
void MinCut() {
cut.clear();
for (int i = 0; i < i += 2) {
if (vis[edges[i].u] && !vis[edges[i].v])
cut.push_back(i);
const int N = 205;
int n, m, M[N];
int main() {
while (~scanf("%d%d", &n, &m)) {
gao.init(n + 2);
int u, v, l,
memset(M, 0, sizeof(M));
for (int i = 0; i < i++) {
scanf("%d%d%d%d", &u, &v, &l, &c);
gao.add_Edge(u, v, c - l, l);
for (int i = 1; i
0) gao.add_Edge(0, i, M[i], 0);
else if (M[i] < 0) gao.add_Edge(i, n + 1, -M[i], 0);
if (!gao.solve(0, n + 1, m)) printf("NO\n");
const int N = 500005;
int n, fa[N], du[N], vis[N];
int out[N],
int main() {
while (~scanf("%d", &n)) {
int ans = 0;
memset(du, 0, sizeof(du));
memset(vis, 0, sizeof(vis));
for (int i = 2; i <= i++) {
scanf("%d", &f);
for (int i = 1; i <= i++) {
if (du[i] == 0)
Q.push(i);
while (!Q.empty()) {
int u = Q.front();
if (u == 1)
if (!vis[u] && !vis[fa[u]]) {
vis[fa[u]] = 1;
out[on++] =
ans += 1000;
du[fa[u]]--;
if (du[fa[u]] == 0) Q.push(fa[u]);
sort(out, out + on);
printf("%d\n", ans);
for (int i = 0; i < i++)
printf("%d%c", out[i], i == on - 1 ? '\n' : ' ');
const int N = 10005;
const int M = 100005;
int n, m, cnt[N];
int u[M], v[M];
int main() {
while (~scanf("%d%d", &n, &m)) {
long long ans = 0;
memset(cnt, 0, sizeof(cnt));
for (int i = 0; i < i++) {
scanf("%d%d", &u[i], &v[i]);
cnt[u[i]]++;
if (v[i] != u[i]) cnt[v[i]]++;
for (int i = 0; i < i++) {
ans += cnt[u[i]];
if (u[i] != v[i]) ans += cnt[v[i]];
printf("%lld\n", ans);
const ll MOD = ;
const int NUMLEN = 105;
struct Bign {
ll num[NUMLEN];
void init(char *str) {
for (int i = strlen(str) - 1; i >= 0; i--) {
if (str[i] == '0') str[i] = '9';
if (str[0] == '0') {
int ca = strlen(str);
for (int i = 0; i = 0; i -= 9) {
for (int j = max(0, i - 8); j = 0; i--) {
num[i] = num[i] + yu * MOD;
yu = num[i] % 2;
num[i] /= 2;
while (len > 1 && num[len - 1] == 0) len--;
bool iszero() {
if (len == 1 && num[0] == 0)
void print() {
for (int i = len - 1; i >= 0; i--) {
if (i != len - 1) printf("%09lld", num[i]);
else printf("%lld", num[i]);
const int N = 105;
char num[N];
struct mat {
int v[35][35];
mat() {memset(v, 0, sizeof(v));}
mat operator * (mat c) {
for (int k = 0; k < k++) {
for (int i = 0; i < i++) {
if (v[i][k] == 0)
for (int j = 0; j < j++) {
if (c.v[k][j] == 0)
ans.v[i][j] = (ans.v[i][j] + v[i][k] * c.v[k][j]) %
mat pow_mod(mat x, Bign k) {
for (int i = 0; i < i++) ans.v[i][i] = 1;
while (!k.iszero()) {
ll sb = k.p2();
if (sb == 1) ans = ans *
int main() {
while (~scanf("%s%d%d", num, &m, &p)) {
n.init(num);
tot = (1<<m);
for (int i = 0; i < i++) {
for (int j = 0; j < j++) {
int flag = 1;
int st = 3;
for (int k = 0; k >k;
if ((sb == 0 || sb == 3) && (i&st) == (j&st)) {
if (flag == 1) A.v[i][j] = 1;
A = pow_mod(A, n);
ll ans = 0;
for (int i = 0; i < i++) {
for (int j = 0; j < j++)
ans = (ans + A.v[i][j]) %
printf("%lld\n", ans);
typedef double T
const double eps = 1e-6;
const int MAXNODE = 305;
const int MAXEDGE = 100005;
struct Edge {
Edge(int u, int v, Type dist) {
this->dist =
struct BellmanFrod {
Edge edges[MAXEDGE];
int first[MAXNODE];
int next[MAXEDGE];
bool inq[MAXNODE];
Type d[MAXNODE];
int p[MAXNODE];
int cnt[MAXNODE];
void init(int n) {
memset(first, -1, sizeof(first));
void add_Edge(int u, int v, Type dist) {
edges[m] = Edge(u, v, dist);
next[m] = first[u];
first[u] = m++;
bool negativeCycle() {
memset(inq, 0, sizeof(inq));
memset(cnt, 0, sizeof(cnt));
for (int i = 0; i
eps + d[u] + e.dist) {
d[e.v] = d[u] + e.
if (!inq[e.v]) {
Q.push(e.v);
inq[e.v] =
if (++cnt[e.v] > n)
const int N = 305;
struct Circle {
double x, y,
void read() {
scanf("%lf%lf%lf", &x, &y, &r);
double dis(Circle a, Circle b) {
double dx = a.x - b.x;
double dy = a.y - b.y;
return sqrt(dx * dx + dy * dy);
int main() {
while (~scanf("%d", &n)) {
for (int i = 0; i < i++) c[i].read();
cc.read();
for (int i = 0; i < i++) {
c[i].x -= cc.x;
c[i].y -= cc.y;
c[i].r += cc.r;
cc.x = cc.y = 0;
gao.init(n);
for (int i = 0; i < i++) {
for (int j = i + 1; j < j++) {
if (c[i].r + c[j].r - eps = 0;
gao.add_Edge(i, j, flag ? tmp : -tmp);
gao.add_Edge(j, i, flag ? -tmp : tmp);
printf("%s\n", !gao.negativeCycle() ? "YES" : "NO");
const int N = 100005;
struct Man {
bool cmp(Man a, Man b) {
if (a.a == b.a) return a.b > b.b;
return a.a < b.a;
int dp[N], save[N],
bool judge(Man a, Man b) {
if (a.a = b.b)
if (a.a >= b.a && a.b <= b.b)
int main() {
while (~scanf("%d", &n)) {
for (int i = 1; i <= i++) {
scanf("%d%d", &man[i].a, &man[i].b);
man[i].id =
sort(man + 1, man + n + 1, cmp);
memset(dp, 0, sizeof(dp));
save[sn++] = 0;
for (int i = 1; i = 1; i--) {
if (dp[i] == sum) {
if (bo) printf(" ");
else bo = 1;
printf("%d", man[i].id);
printf("\n");
const int MAXN = 2005;
struct bign {
ll num[MAXN];
memset(num, 0, sizeof(num));
bign (ll number) {*this =}
bign (const char* number) {*this =}
void DelZero ();
void Put ();
void operator = (ll number);
void operator = (char* number);
bool operator
(const bign& b) const { return b < * }
bool operator <= (const bign& b) const { return !(b = (const bign& b) const { return !(*this < b); }
bool operator != (const bign& b) const { return b < *this || *this <}
bool operator == (const bign& b) const { return !(b != *this); }
void operator ++ ();
void operator -- ();
bign operator + (const int& b);
bign operator + (const bign& b);
bign operator - (const int& b);
bign operator - (const bign& b);
bign operator * (const ll& b);
bign operator * (const bign& b);
bign operator / (const ll& b);
//bign operator / (const bign& b);
int operator % (const int& b);
int prime[10005], pn = 0, vis[10005];
void getprime() {
for (int i = 2; i < 10000; i++) {
if (vis[i])
prime[pn++] =
for (int j = i * j < 10000; j += i)
vis[j] = 1;
const int N = 105;
int A[N][N];
int gauss() {
int i = 0, j = 0, k, r,
while (i < m && j < n) {
for (k = k < k++)
if (A[k][j]) {r =}
if (A[r][j]) {
if (r != i) for (int k = 0; k <= k++) swap(A[r][k], A[i][k]);
for (u = i + 1; u < u++) if (A[u][j])
for (k = k <= k++) A[u][k] ^= A[i][k];
int main() {
getprime();
while (~scanf("%d%d", &m, &n)) {
memset(A, 0, sizeof(A));
for (int k = 0; k < k++) {
scanf("%d", &num);
for (int i = 0; i < i++) {
if (num % prime[i] == 0) {
int cnt = 0;
while (num % prime[i] == 0) {
num /= prime[i];
if (cnt % 2) A[i][k] = 1;
int sb = gauss();
bign ans = 1;
for (int i = 0; i = 0; i--)
printf("%lld", num[i]);
void bign::operator = (char* number) {
len = strlen (number);
for (int i = 0; i < i++)
num[i] = number[len-i-1] - '0';
DelZero ();
void bign::operator = (ll number) {
while (number) {
num[len++] = number%10;
number /= 10;
DelZero ();
bool bign::operator < (const bign& b) const {
if (len != b.len)
return len = 0; i--)
if (num[i] != b.num[i])
return num[i] < b.num[i];
void bign::operator ++ () {
int s = 1;
for (int i = 0; i < i++) {
s = s + num[i];
num[i] = s % 10;
while (s) {
num[len++] = s%10;
void bign::operator -- () {
if (num[0] == 0 && len == 1)
int s = -1;
for (int i = 0; i = 0)
DelZero ();
bign bign::operator + (const int& b) {
return *this +
bign bign::operator + (const bign& b) {
int bignSum = 0;
for (int i = 0; i < len || i < b. i++) {
if (i < len) bignSum += num[i];
if (i < b.len) bignSum += b.num[i];
ans.num[ans.len++] = bignSum % 10;
bignSum /= 10;
while (bignSum) {
ans.num[ans.len++] = bignSum % 10;
bignSum /= 10;
bign bign::operator - (const int& b) {
return *this -
bign bign::operator - (const bign& b) {
ll bignSub = 0;
for (int i = 0; i < len || i < b. i++) {
bignSub += num[i];
if (i < b.len)
bignSub -= b.num[i];
ans.num[ans.len++] = (bignSub + 10) % 10;
if (bignSub < 0) bignSub = -1;
else bignSub = 0;
ans.DelZero();
bign bign::operator * (const ll& b) {
ll bignSum = 0;
for (int i = 0; i < i++) {
bignSum += num[i] *
ans.num[i] = bignSum % 10;
bignSum /= 10;
while (bignSum) {
ans.num[ans.len++] = bignSum % 10;
bignSum /= 10;
bign bign::operator * (const bign& b) {
ans.len = 0;
for (int i = 0; i < i++){
int bignSum = 0;
for (int j = 0; j = 0; i--) {
s = s * 10 + num[i];
ans.num[i] = s/b;
ans.DelZero();
int bign::operator % (const int& b) {
int s = 0;
for (int i = len-1; i >= 0; i--) {
s = s * 10 + num[i];
ans.num[i] = s/b;截止频率6KHZ的低通滤波器 电容电阻如何选取_百度知道
截止频率6KHZ的低通滤波器 电容电阻如何选取
我有更好的答案
首先选定电阻，阻值R在0.01欧-1M欧范围内选取，注意取标准值。以下步骤a、b任选一a. 计算电容值C=1/（2*pi*f*R），从标准电容容值表中找最接近的容值。f为截止频率，pi为圆周率b. 从下图（电抗-频率图，横轴为频率，纵轴为电抗）中，在纵轴上找到电抗=R的横线，然后找到频率为f的竖线，横线竖线的交点的所在的斜线（单位为uF的斜线）对应的容值即为要选取的电容值。这种方法更快速，更适合于工程应用。
关于这个建议去硬之城官网看看哦,能快速解决问题 服务态度又好这个很多地方都做不到的。
为您推荐：
其他类似问题
换一换
回答问题，赢新手礼包
个人、企业类
违法有害信息,请在下方选择后提交
色情、暴力
我们会通过消息、邮箱等方式尽快将举报结果通知您。扫二维码下载作业帮
3亿+用户的选择
下载作业帮安装包
扫二维码下载作业帮
3亿+用户的选择
f=1/(2*pi*R*C) f表示频率 RC分别表示电阻和电容 问之间的数值换算 R=2K C=0.47UF 求f
作业帮用户
扫二维码下载作业帮
3亿+用户的选择
把已知值带进去算呗!f=1/(2*3.14*2**0./(5.)≈169.4(hz)
为您推荐：
其他类似问题
扫描下载二维码无源低通滤波器，截止频率f=1/2πrRC是怎么推出来的?_百度知道
无源低通滤波器，截止频率f=1/2πrRC是怎么推出来的?
无源RC低通滤波器，由电阻R和电容C串联构成，从C输出电压。假设频率为f，容抗Xc=j/2πfC电容上的分压为：Uo=(Xc/(Xc+R))*Ui将Xc=j/2πfC代入，可得：Uo=Ui/(1+j2πfRC)或表示为Af=Uo/Ui=1/(1+j2πfRC)只考虑幅值|Af|=1/√（1+（2πfRC）^2）截止频率是指|Af|衰减-3db对应的频率，也就是|Af|=1/√2时对应的频率。显然，此时f=1/2πfRC。
采纳率：87%
来自团队：
问题补充： . R1=R2=10K,C1=187.6nF,C2=93.78nF。留下邮箱，可发Filter Solutions 10设计软件
为您推荐：
其他类似问题
您可能关注的内容
低通滤波器的相关知识
换一换
回答问题，赢新手礼包
个人、企业类
违法有害信息,请在下方选择后提交
色情、暴力
我们会通过消息、邮箱等方式尽快将举报结果通知您。知道低通滤波器频率参数如何求电阻电容。急！！！_百度知道
知道低通滤波器频率参数如何求电阻电容。急！！！
我有更好的答案
根据公式来计算撒。f=1/2*pi*RC；我估计你是不是想配置R、C的值，然后达到相应的截止频率。你可以将现有的C确定一下嘛，然后去配电阻的值，因为电阻的值相对来说好配一些。
为您推荐：
其他类似问题
低通滤波器的相关知识
换一换
回答问题，赢新手礼包
个人、企业类
违法有害信息,请在下方选择后提交
色情、暴力
我们会通过消息、邮箱等方式尽快将举报结果通知您。
