美文网首页
冬季赛题解

冬季赛题解

作者: 云中翻月 | 来源:发表于2019-12-04 16:29 被阅读0次

本场比赛题目难度分布
简单题：
硕哥的签到题（出处：原创题）
硕哥的最短路（出处：百度之星2019全国初赛第三场）
硕哥的字符串（出处：百度之星2019全国初赛第二场）
硕哥的大整数（出处：快速乘模板题）
硕哥的全排列（出处：全排列模板题）
中等题：
硕哥的表达式（出处：中缀表达式解析模板题）
硕哥的托儿所（出处：HAOI2008 糖果传递）
硕哥的布尔式（出处：Face Book 全球初赛 Mr.X）
困难题：
硕哥的数学题（出处：原创题）
硕哥的树贸易（出处：POJ3728 The merchant）
硕哥的电路图（出处：POJ3532 Resistance）
以下是逐题题解：
简单题：
硕哥的签到题
签到题，不再赘述。
代码如下

/*

*/
#define method_1
#ifdef method_1
/*

*/
#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cmath>
#include<set>
#include<map>
#include<queue>
#include<stack>
#include<vector>
#include<cstring>
#include<cstdlib>
#include<iomanip>
#include<ctime>
#include<string>
#define D(x) cout<<#x<<" = "<<x<<"  "
#define E cout<<endl
using namespace std;
typedef long long ll;
typedef pair<int,int>pii;
const int maxn=+5;
const int INF=0x3f3f3f3f;

int main() {
    ios::sync_with_stdio(false);
    cout<<"shuo ge is handsome!!!"; 
    return 0;
}
#endif
#ifdef method_2
/*

*/

#endif
#ifdef method_3
/*

*/

#endif

硕哥的最短路
手算一下n为3，4，5时候的结果，就会发现规律。
答案就是1\oplus n
代码如下

/*

*/
#define method_1
#ifdef method_1
/*

*/
#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cmath>
#include<set>
#include<map>
#include<queue>
#include<stack>
#include<vector>
#include<cstring>
#include<cstdlib>
#include<iomanip>
#include<ctime>
#include<string>
#define D(x) cout<<#x<<" = "<<x<<"  "
#define E cout<<endl
using namespace std;
typedef long long ll;
typedef pair<int,int>pii;
const int maxn=+5;
const int INF=0x3f3f3f3f;
int n;
int main() {
    ios::sync_with_stdio(false);
    cin>>n;
    cout<<(1^n);
    return 0;
}
#endif
#ifdef method_2
/*

*/

#endif
#ifdef method_3
/*

*/

#endif

硕哥的字符串
我们注意到，异或的本质是不进位加法。因此，每一次异或后，结果最多增大一。而如果每一次加法后，结果必然增大一。于是，只要贪心的将所有问号全部换成加号即可。
代码如下

/*

*/
#define method_1
#ifdef method_1
/*

*/
#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cmath>
#include<set>
#include<map>
#include<queue>
#include<stack>
#include<vector>
#include<cstring>
#include<cstdlib>
#include<iomanip>
#include<ctime>
#include<string>
#define D(x) cout<<#x<<" = "<<x<<"  "
#define E cout<<endl
using namespace std;
typedef long long ll;
typedef pair<int,int>pii;
const int maxn=+5;
const int INF=0x3f3f3f3f;
string s;
int main() {
    ios::sync_with_stdio(false);
    cin>>s;
    cout<<s.length()/2+1;
    return 0;
}
#endif
#ifdef method_2
/*

*/

#endif
#ifdef method_3
/*

*/

#endif

硕哥的大整数
传统的C++数据类型中，不存在某个数字的范围达到2^{128}。因此我们要考虑通过一种“乘法转化为加法”的方式，来优化我们的计算过程，使得计算中不产生溢出。
我们知道乘法其实就是把很多个加法运算合到一起。现在我们的乘法会爆范围，那我们就把它转化为加法。但是我们不可能一个一个的加，这样复杂度会是 O(n) 级别。所以我们模仿2进制加法操作来完成。
代码如下

/*

*/
#define method_1
#ifdef method_1
/*

*/
#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cmath>
#include<set>
#include<map>
#include<queue>
#include<stack>
#include<vector>
#include<cstring>
#include<cstdlib>
using namespace std;
typedef long long ll;
const int maxn=+5;
const ll INF=0x3f3f3f3f3f3f3f3fll;
ll a,b,p;
ll work(ll a,ll b,ll p){
    ll ans=0;
    while(b){
        if(b&1) ans=(ans+a)%p;
        a=(a*2)%p;
        b>>=1;
    }
    return ans;
}
int main() {
    ios::sync_with_stdio(false);
    cin>>a>>b>>p;
    cout<<work(a,b,p);
    return 0;
}
#endif
#ifdef method_2
/*

*/

#endif
#ifdef method_3
/*

*/

#endif

硕哥的全排列
这是一道模板题，可以通过调用next_permutation函数，或者直接手写递归实现。
代码提供了上述的两种方法。
代码如下

/*

*/
#define method_2
#ifdef method_1
/*

*/
#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cmath>
#include<set>
#include<map>
#include<queue>
#include<stack>
#include<vector>
#include<cstring>
#include<cstdlib>
using namespace std;
typedef long long ll;
const int maxn=10+5;
const int INF=0x3f3f3f3f;
int n,a[maxn];
int main() {
    ios::sync_with_stdio(false);
    cin>>n;
    for(int i=1;i<=n;i++){
        a[i]=i;
    }
    do{
        for(int i=1;i<=n;i++){
            cout<<a[i]<<" ";
        }
        cout<<endl;
    }while(next_permutation(a+1,a+n+1));
    return 0;
}
#endif
#ifdef method_2
/*

*/
#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cmath>
#include<set>
#include<map>
#include<queue>
#include<stack>
#include<vector>
#include<cstring>
#include<cstdlib>
using namespace std;
typedef long long ll;
const int maxn=10+5;
const int INF=0x3f3f3f3f;
int n,order[maxn],vis[maxn];
void dfs(int x){
    if(x==n+1){
        for(int i=1;i<=n;i++) cout<<order[i]<<" ";
        cout<<endl;
        return; 
    }
    for(int i=1;i<=n;i++){
        if(vis[i]) continue;
        vis[i]=1;
        order[x]=i;
        dfs(x+1);
        vis[i]=0;
        order[x]=0;//由于有vis数组的限制 所以这一行可以省略 
    }
}
int main() {
    ios::sync_with_stdio(false);
    cin>>n;
    dfs(1);
    return 0;
}
#endif
#ifdef method_3
/*

*/

#endif

中等题：
硕哥的布尔式
我们考虑最后一步运算，会出现如下三种情况
0 运算符 0
0 运算符 x
x 运算符 x
其中只有第二种情况的结果是有可能不确定的，而这种情况下，最多只要调整一下这个最后一次进行的运算符即可。
因此我们首先将字符串中的所有x换成0后，计算一次答案。然后将字符串中的所有x换成1后，再计算一次答案。
如果两次答案相同，则意味着x的取值不会影响结果。
否则，只要一次操作即可。
代码如下

/*

*/
#define method_1
#ifdef method_1
/*

*/
#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cmath>
#include<set>
#include<map>
#include<queue>
#include<stack>
#include<vector>
#include<cstring>
#include<cstdlib>
#include<iomanip>
#include<ctime>
#include<string>
#define D(x) cout<<#x<<" = "<<x<<"  "
#define E cout<<endl
using namespace std;
typedef long long ll;
typedef pair<int,int>pii;
const int maxn=300+5;
const int INF=0x3f3f3f3f;
int T,n,kase=0;
stack<char>st;
int cal(string s){
    for(int i=0;i<n;i++){
        if(s[i]!=')') st.push(s[i]);
        else{
            char a=st.top();st.pop();
            char op=st.top();st.pop();
            char b=st.top();st.pop();
            st.pop();
            int ans;
            if(op=='&')ans=(a-'0')&(b-'0');
            if(op=='|')ans=(a-'0')|(b-'0');
            if(op=='^')ans=(a-'0')^(b-'0');
            st.push((char)(ans+'0'));
        }
    }
    return (int)(st.top()-'0');
}
int main() {
    ios::sync_with_stdio(false);
    cin>>T;
    while(T--){
        cout<<"Case #"<<++kase<<": ";
        string s;
        cin>>s;n=s.length();
        if(n==1){
            if(s[0]=='0'||s[0]=='1') cout<<"0"<<endl;
            else cout<<"1"<<endl;
            continue;
        }
        string s1=s,s2=s;
        for(int i=0;i<n;i++){
            if(s1[i]=='x')s1[i]='0';
            if(s1[i]=='X')s1[i]='1';
        }
        for(int i=0;i<n;i++){
            if(s2[i]=='x')s2[i]='1';
            if(s2[i]=='X')s2[i]='0';
        }   
        if(cal(s1)==cal(s2)) cout<<"0"<<endl;
        else cout<<"1"<<endl;   
    }
    return 0;
}
#endif
#ifdef method_2
/*

*/

#endif
#ifdef method_3
/*

*/

#endif

硕哥的托儿所
环形传递有个结论，必然存在两个点之间没有传递，这个可以通过反证法证明。
然后写出前缀和的答案，枚举断开处，发现当断开处是前缀和的中位数时，就有了最优情况。
代码如下

/*

*/
#define method_1
#ifdef method_1
/*

*/
#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cmath>
#include<set>
#include<map>
#include<queue>
#include<stack>
#include<vector>
#include<cstring>
#include<cstdlib>
using namespace std;
typedef long long ll;
const int maxn=1000000+5;
const int INF=0x3f3f3f3f;
ll n,a[maxn],s[maxn];
ll sum=0,ans=0;
int main() {
    ios::sync_with_stdio(false);
    cin>>n;
    for(int i=1;i<=n;i++){
        cin>>a[i];
        sum+=a[i];
    }
    ll mid=sum/n;
    for(int i=1;i<=n;i++){
        a[i]-=mid;
        s[i]=s[i-1]+a[i];
    //  cout<<s[i]<<" ";
    }
    sort(s+1,s+n+1);
    for(int i=1;i<=n;i++){
        ans+=abs(s[i]-s[(n+1)/2]);
    }
    cout<<ans;
    return 0;
}
#endif
#ifdef method_2
/*

*/

#endif
#ifdef method_3
/*

*/

#endif

硕哥的表达式
中规中矩的表达式解析问题，由于代码量较长，因此放在了中等题的位置。
代码如下

/*

*/
#include<cstdio>
#include<cstring>
#include<stack>
#include<iostream>
using namespace std;
stack<int> num;
stack<char> ch;
string s;
int l;
int getnum(char a) {
    if (a=='+'||a=='-') return 0;
    else if (a=='*'||a=='/') return 1;
    else if (a=='^') return 2;
    else return -1;
}
void count() {
    int a=num.top();
    num.pop();
    if (ch.top()=='+') a=num.top()+a;
    else if (ch.top()=='-') a=num.top()-a;
    else if (ch.top()=='*') a=num.top()*a;
    else if (ch.top()=='/'&&a!=0) a=num.top()/a;
    else if (ch.top()=='^') {
        int s=1;
        for (int i=0; i<a; i++) s*=num.top();
        a=s;
    }
    num.pop();
    num.push(a);
    ch.pop();
}
void output(stack<int>x){
    cout<<"数值栈 "; 
    int cnt=0;
    while(!x.empty()){
        int temp=x.top();
        cout<<temp<<" ";
        x.pop();
    }
    cout<<endl;
}
void output1(stack<char>x){
    cout<<"操作符栈 "; 
    int cnt=0;
    while(!x.empty()){
        char temp=x.top();
        x.pop();
        cout<<temp<<" ";
    }
    cout<<endl;
}
int main() {
    cin>>s;
    if (s[0]=='-') s="0"+s;
    for (int i=2; i<s.size(); i++)
        if (s[i]=='-'&&s[i-1]=='(') s.insert(i,"0"),i++; //将负号转化为减号 
    l=s.size();
    for (int i=0; i<l;) {
        if (s[i]>='0'&&s[i]<='9') {
            int x=0;
            for (; s[i]>='0'&&s[i]<='9'; i++) x=x*10+s[i]-'0';
            num.push(x);
        } else if (s[i]==')') {
            while (num.size()>1&&ch.top()!='(') count();
            i++;
            //printf("%d\n",ch.size());
            if (!ch.empty()) ch.pop(); //删除对应左括号 
        } else {
            if (s[i]=='(') {
                ch.push(s[i]);
                i++;
                continue;
            }
            while (num.size()>1&&getnum(ch.top())>=getnum(s[i])) count();
            ch.push(s[i]);
            i++;
        }
    }
    while (!ch.empty()&&ch.top()!='(') count();
    printf("%d\n",num.top());
}

困难题：
硕哥的数学题
前置知识：
莫比乌斯函数：
μ(d)的定义是:
1 当d=1时，μ(d)=1。
2 当d=\Pi_{i=1}^{k}p_i，且p_i为互异素数时，\mu(d)=(-1)^k。(说直白点，就是d分解质因数后，没有幂次大于平方的质因子，此时函数值根据分解的个数决定)。
3 只要当d含有任何质因子的幂次大于等于2，则函数值为0。
莫比乌斯反演：
定理：F(n)和f(n)是定义在非负整数集合上的两个函数，并且满足条件：
F(n)=\sum_{d|n}f(d)
那么存在一个结论：
f(n)=\sum_{d|n}\mu(d)F(\lfloor\frac{n}{d}\rfloor)
我们设：
f(k)为gcd(i,j)=k的个数，F(l)为gcd(i,j)=l和l的倍数的个数
f(k)=\sum_{i=1}^{a}\sum_{j=1}^{b}[gcd(i,j)=k]
F(l)=\sum_{l|k}f(k)=\lfloor\frac{n}{l}\rfloor\lfloor\frac{m}{l}\rfloor
则可以由莫比乌斯反演可以推出：
f(n)=\sum_{n|k}\mu(\lfloor\frac{k}{n}\rfloor)F(k)
设完这两个函数之后，我们便发现，Ans=n*m-f(1)
于是就直接开始推答案：
Ans=n*m-\sum_{1|k}\mu(\lfloor\frac{k}{1}\rfloor)F(k)
枚举\lfloor\frac{k}{1}\rfloor设为t
Ans=n*m-\sum_{t=1}^{min(\lfloor\frac{n}{1}\rfloor,\lfloor\frac{m}{1}\rfloor)}\mu(t)\lfloor\frac{a}{t*1}\rfloor\lfloor\frac{b}{t*1}\rfloor
这时候，这个式子已经可以做到O(n)的时间复杂度了，但是因为有多组数据，所以我们再用一下整除分块，这题就可以做到O(\sqrt n)了。
代码如下

#include<iostream>
#include<cstdio>
#define ll long long
#define re register
using namespace std;
const int N=100009;
int T,pri[N],mu[N],cnt;
ll sum[N];
bool isp[N];
int Cirno() {
    mu[1]=1;
    for(re int i=2; i<N; ++i) {
        if(!isp[i])pri[++cnt]=i,mu[i]=-1;
        for(re int j=1; j<=cnt; ++j) {
            if(i*pri[j]>=N)break;
            isp[i*pri[j]]=1;
            if(!(i%pri[j])) {
                mu[i*pri[j]]=0;
                break;
            } else mu[i*pri[j]]=-mu[i];
        }
    }
    for(re int i=1; i<N; ++i)sum[i]=sum[i-1]+mu[i];
}
void solve(int n,int m,int k) {
    ll ans=0;
    n/=k,m/=k;
    int lim=min(n,m);
    for(int i=1; i<=lim;) {
        ll j=min(n/(n/i),m/(m/i));
        ans+=1ll*(sum[j]-sum[i-1])*(n/i)*(m/i);
        i=j+1;
    }
    printf("%lld\n",n*m-ans);
}
int main() {
    Cirno();
    scanf("%d",&T);
    while(T--) {
        int n,m;
        scanf("%d%d",&n,&m);
        solve(n,m,1);
    }
    return 0;
}

硕哥的树贸易
因为存在买卖顺序的问题，问题不能单纯的理解为在树链上求解最值。
考虑答案的产生过程，有三种情况。
1 在from到lca的过程中完成买卖。
2 在lca到to的过程中完成买卖。
3 在from到lca的过程中以这一段的最低价格买入，在lca到to的过程中以这一段的最高价格卖出。
因此将深度进行二进制划分，完成几个数组的dp。
up数组，up[i][j]维护i到i节点往上2^j的节点的最大差价
down数组，down[i][j]维护i节点往下2^j到i的节点的最大差价
Max数组, Max[i][j]维护i到i节点往上2^j的节点之间价格的最大值
Min数组，Min[i][j]维护i到i节点往上2^j的节点之间价格的最小值
最后答案通过组合这些二进制数组得到。具体内容详见注释。本题在转移时细节较多，需要细心。
代码如下

/*

*/
#define method_1
#ifdef method_1
/*

*/
#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cmath>
#include<set>
#include<map>
#include<queue>
#include<stack>
#include<vector>
#include<cstring>
#include<cstdlib>
#define D(x) cout<<#x<<" = "<<x<<"  "
#define E cout<<endl
using namespace std;
typedef long long ll;
typedef pair<int,int>pii;
const int maxn=50000+5;
const int INF=0x3f3f3f3f;
int n,q;
struct node {
    int from,to;
} edge[maxn<<1];
int t,head[maxn],tot=0,fa[maxn][20],d[maxn],w[maxn],up[maxn][20],down[maxn][20],Max[maxn][20],Min[maxn][20];
/*
up数组，up[i][j]维护i到i节点往上2^j的节点的最大差价
down数组，down[i][j]维护i节点往下2^j到i的节点的最大差价
Max数组, Max[i][j]维护i到i节点往上2^j的节点之间价格的最大值
Min数组，Min[i][j]维护i到i节点往上2^j的节点之间价格的最小值
*/
void add(int u,int v) {
    edge[++tot].to=v;edge[tot].from=head[u];head[u]=tot;
}
void bfs() {
    queue<int>q;
    q.push(1);
    d[1]=1;
    while(!q.empty()) {
        int x=q.front();
        q.pop();
        for(int i=head[x]; i; i=edge[i].from) {
            int y=edge[i].to;
            if(!d[y]) {
                q.push(y);
                d[y]=d[x]+1;
                Max[y][0]=max(w[x],w[y]);
                Min[y][0]=min(w[x],w[y]);
                up[y][0]=max(0,w[x]-w[y]);
//              D(x);D(y);D(w[x]);D(w[y]);D(up[y][0]);E;
                down[y][0]=max(0,w[y]-w[x]);
                fa[y][0]=x;
                int res1,res2;
                for(int j=1; j<=t; j++) {
                    fa[y][j]=fa[fa[y][j-1]][j-1];
                    Max[y][j]=max(Max[y][j-1],Max[fa[y][j-1]][j-1]);
                    Min[y][j]=min(Min[y][j-1],Min[fa[y][j-1]][j-1]);
                    res1=max(0,Max[fa[y][j-1]][j-1]-Min[y][j-1]);
                    res2=max(up[fa[y][j-1]][j-1],up[y][j-1]);
//                  D(y);D(j);D(res1);D(res2);D(Max[fa[y][j-1]][j-1]);D(Min[y][j-1]);E;
                    up[y][j]=max(res1,res2);
                    res1=max(0,Max[y][j-1]-Min[fa[y][j-1]][j-1]);
                    res2=max(down[fa[y][j-1]][j-1],down[y][j-1]);
                    down[y][j]=max(res1,res2);
                }
            }
        }
    }
}
int lca(int x,int y) {
    if(d[x]>d[y]) swap(x,y);
    for(int i=t; i>=0; i--) {
        if(d[fa[y][i]]>=d[x]) {
            y=fa[y][i];
        }
    }
    if(x==y) return x;
    for(int i=t; i>=0; i--) {
        if(fa[x][i]!=fa[y][i]) {
            x=fa[x][i];
            y=fa[y][i];
        }
    }
    return fa[x][0];
}
int query_up(int x,int dep,int &val){ //val:x到lca的最大差值 
    val=0;
    int res=INF; //res:x到lca的最小值 
    for(int i=t;i>=0;i--){
        if(dep&(1<<i)){
            val=max(val,up[x][i]);
            val=max(val,Max[x][i]-res); //先算val保证此时的res表示的最小值一定在x以下（即对应点深度大于x） 
            res=min(res,Min[x][i]);
            x=fa[x][i];
        }
    }
    return res;
}
int query_down(int x,int dep,int &val){ //val:lca到x的最大差值 
    val=0;
    int res=0; //res:lca到x的最大值 
    for(int i=t;i>=0;i--){
        if(dep&(1<<i)){
            val=max(val,down[x][i]);
            val=max(val,res-Min[x][i]); //先算val保证此时的res表示的最小值一定在x以上（即对应点深度小于x） 
            res=max(res,Max[x][i]);
            x=fa[x][i];
        }
    }
    return res;
}
int main() {
//  ios::sync_with_stdio(false);
    scanf("%d",&n);
    t=int((log(double(n))/log(2.0)))+1;
//  D(t);E;
    for(int i=1;i<=n;i++) scanf("%d",&w[i]);
    int from,to;
    for(int i=1;i<=n-1;i++) scanf("%d%d",&from,&to),add(from,to),add(to,from);
    bfs();
    /* 
    for(int i=1;i<=n;i++){
        for(int j=0;j<=t;j++){
            D(i);D(j);D(Min[i][j]);D(Max[i][j]);D(up[i][j]);D(down[i][j]);E;
        }
        E;
    }
    */ 
    scanf("%d",&q);
    while(q--){
        scanf("%d%d",&from,&to);
        int temp=lca(from,to);
        int a,b,val1,val2;
        //a:from到lca的最小值
        //b:lca到to的最大值
        //val1:from到lca的最大差价
        //val2:lca到to的最大差价 
        a=query_up(from,d[from]-d[temp],val1);
        b=query_down(to,d[to]-d[temp],val2);
        int ans=max(0,max(max(val1,val2),b-a));
        printf("%d\n",ans);
    }
    return 0;
}
#endif
#ifdef method_2
/*

*/

#endif
#ifdef method_3
/*

*/

#endif

硕哥的电路图
在电路中，很难直接根据输入判断每条导线中电流的流向。
因此需要基尔霍夫定律来列出每个点电位的方程。
剩下来的，就是高斯消元了。
代码如下

/*

*/
#define method_1
#ifdef method_1
/*

*/
#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cmath>
#include<set>
#include<map>
#include<queue>
#include<stack>
#include<vector>
#include<cstring>
#include<cstdlib>
#include<iomanip>
#include<ctime>
#include<string>
#include<bitset>
#define D(x) cout<<#x<<" = "<<x<<"  "
#define E cout<<endl
using namespace std;
typedef long long ll;
typedef pair<int,int>pii;
const int maxn=100+5;
const int INF=0x3f3f3f3f;
const double eps=1e-4;
int n,m;
double a[maxn][maxn],x[maxn];//  a和x分别为方程的左边的矩阵和等式右边的值，求解之后x存的就是结果
int equ,var;//  方程数和未知数个数
int Gauss() {//  返回0表示无解，1表示有解
    int i,j,k,col,max_r;
    for(k=1,col=1; k<=equ&&col<=var; k++,col++) {
        max_r=k;
        for(i=k+1; i<=equ; i++)if(fabs(a[i][col])>fabs(a[max_r][col]))max_r=i;
        if(fabs(a[max_r][col])<eps)return 0;
        if(k!=max_r) {
            for(j=col; j<=var; j++)swap(a[k][j],a[max_r][j]);
            swap(x[k],x[max_r]);
        }
        x[k]/=a[k][col];
        for(j=col+1; j<=var; j++)a[k][j]/=a[k][col];
        a[k][col]=1;
        for(i=0; i<=equ; i++)if(i!=k) {
                x[i]-=x[k]*a[i][k];
                for(j=col+1; j<=var; j++)a[i][j]-=a[k][j]*a[i][col];
                a[i][col]=0;
            }
    }
    return 1;
}
int main() {
//  ios::sync_with_stdio(false);
    scanf("%d%d",&n,&m);
    int from,to;
    double r;
    for(int i=1; i<=m; i++) {
        scanf("%d%d%lf",&from,&to,&r);
        //对于电路中的一条from到to，阻值为r的边。方程组中会有四个项的系数受到影响。
        a[from][from]+=1.0/r,a[to][to]+=1.0/r,a[from][to]-=1.0/r,a[to][from]-=1.0/r;
    }
//  a[n][n]+=1.0;
    x[1]=1.0,x[n]=-1.0;
    /*
    for(int i=1; i<=n; i++) {
        for(int j=1; j<=n; j++) {
            printf("%.2f ",a[i][j]);
        }
        E;
    }
    */
    equ=var=n;
    Gauss();
    printf("%.2lf ",x[1]-x[n]); //事实上 x[n]等于0恒成立 
//  for(int i=1; i<=n; i++) printf("%.2lf ",x[i]);
    return 0;
}
#endif

相关文章

  • 冬季赛题解

    本场比赛题目难度分布简单题：硕哥的签到题（出处：原创题）硕哥的最短路（出处：百度之星2019全国初赛第三场）硕哥的...

  • 排位赛 09 题解

    排位赛 09 题解 A - Fox and Number Game CodeForces - 389A 题意 给出...

  • 20180625比赛日记——阅读官方赛题解读以及第一名的思路

    官方赛题解读——关于风控大脑赛题解题入门你不可不知的一些事儿目前第一名“凤凰还未涅槃”的经验分享帖——支付风险识别...

  • SCNUOJ 2020 软件学院 天梯赛选拔赛 + 蓝桥杯热身赛

    SCNUOJ 2020 软院天梯赛选拔赛 + 蓝桥杯热身赛 题解 写在前面 本次比赛面向软件学院2017、2018...

  • 组队赛 01 题解（部分）

    组队赛 01 题解 感想 组队赛用的是11年福州赛区的网络赛。 这场的题目A、F、H、J是大家都能做的，剩下的题目...

  • 协会内部赛题解

    完成情况： 合计：250+200+300*0.7=660 Patches' Punches 关键代码部分如下： 验...

  • 说说我们学校的冬季长跑

    从零九年开始，每年元旦前，我校都要举办“迎新年”冬季长跑活动，又名冬季越野赛。说是越野赛，还真就是“越野”。上午大...

  • 冬季萝卜赛人参

    “ 白萝卜作为日常生活中物美价廉的蔬菜，深受老百姓喜爱，同时也是食药同源的一款食材。白萝卜中膳食纤维、钙、钾、镁、...

  • 冬季越野赛

    一年一度的冬季越野赛在今天下午如期而至 儿子很荣幸能成为其中一员。中午，为鼓励孩子在比赛中奋力拼搏、突破自我，给吃...

  • 神奇小羊淘喜(19)

    第三章 心想事成 19、冬季三项赛 马上就要进行冬季三项赛了,我们各班都做好了充分的准备工作。 ...

网友评论

      本文标题：冬季赛题解

      本文链接：https://www.haomeiwen.com/subject/uuoyictx.html

      延伸阅读

      深度阅读

      • 您也可以注册成为美文阅读网的作者，发表您的原创作品、分享您的心情！

      栏目导航

      热点阅读

      关于我们|服务条款|联系我们|冬季赛题解|投稿指南|网站地图|RSS订阅|排版工具|手机版

      提供经典美文摘抄,优美散文欣赏,现代诗歌精选,短篇小说,心情随笔,表白情书范文,故事会在线阅读欣赏

      Copyright © 2014-2023 Haomeiwen.com All Rights Reserved. 好美文阅读网 版权所有

      备案信息：桂公网安备 45052102000051号 · 桂ICP备13007215号-3

      本站所收录作品、热点评论等信息部分来源互联网，目的只是为了系统归纳学习和传递资讯

      所有作品版权归原创作者所有，与本站立场无关，如不慎侵犯了你的权益，请联系我们告知，我们将做删除处理！