第一題：dfs+剪枝
k位數不能所有的數字都遍歷一遍，必須有選擇的。選擇k位數和爲m的。
remain爲剩下未分配數的位置的和。remain必須小於等於剩下的位數*9。因爲若是大於的話，剩下的所有位數都爲9，都滿足不了所有位加起來爲m。比如k=3,m=20，如果第一位爲1，則return。因爲無論後面兩位是什麼，這個三位數的和都小於20。所以
這樣剪枝。就是在位數爲k，所有位和爲m的數裏找了。
cnt爲當前已經分配了數字的位數。remain爲剩下的位數的數字之和。gdb爲輾轉相除法。當時差點沒想起來，真的沒印象了，名字都記錯。判斷質數，等於2也返回false，是因爲要求最大公約數爲大於2的質數。
#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
struct node{
LL val;
int n;
friend bool operator <(node a,node b)
{
if(a.n!=b.n)
{
return a.n<b.n;
}else
{
return a.val<b.val;
}
}
};
int N,k,m;
set<node> ans;
bool isprime(int x)
{
if(x<=2) return false;
for(int i=2;i*i<=x;i++)
{
if(x%i==0) return false;
}
return true;
}
int gdb(int a,int b)
{
if(b==0) return a;
else{
a = a%b;
return gdb(b,a);
}
}
int sum(LL x)
{
int sum = 0;
while(x!=0)
{
sum+=x%10;
x/=10;
}
return sum;
}
void dfs(int cnt,LL num,int remain)
{
if(remain>(k-cnt)*9) return;
if(cnt==k)
{
LL temp = num + 1;
int n = sum(temp);
int x = gdb(max(m,n),min(m,n));
if(isprime(x))
{
ans.insert(node{num,n});
}
return;
}
for(int i=0;i<=min(remain,9);i++)
{
if(cnt==0&&i==0) continue;
dfs(cnt+1,num*10+i,remain-i);
}
}
int main()
{
scanf("%d",&N);
for(int i=1;i<=N;i++)
{
ans.clear();
scanf("%d%d",&k,&m);
dfs(0,0,m);
printf("Case %d\n",i);
if(ans.size()==0)
{
printf("No Solution\n");
}else
{
for(auto it:ans)
{
printf("%d %ld\n",it.n,it.val);
}
}
}
return 0;
}
結果：
第二題：
經典的鏈與鏈之間的操作。用unordered_map存初始數據。再從第一個結點開始遍歷。把兩個鏈存進v1,v2。
再遍歷v1,v2。把它按照規則存進ans。再輸出ans。注意最後一個結點。以及地址的位數。要注意，是誰長誰是v1.而不是第一個鏈。
#include<bits/stdc++.h>
using namespace std;
struct node{
int add;
int val;
int next1;
};
int root1,root2,m;
unordered_map<int,node> hash1;
vector<node> v1,v2,ans,temp;
int main()
{
scanf("%d%d%d",&root1,&root2,&m);
for(int i=0;i<m;i++)
{
int add,val,next1;
scanf("%d%d%d",&add,&val,&next1);
hash1[add]=node{add,val,next1};
}
int root = root2;
while(root!=-1)
{
v1.push_back(hash1[root]);
root = hash1[root].next1;
}
root = root1;
while(root!=-1)
{
v2.push_back(hash1[root]);
root = hash1[root].next1;
}
if(2*v1.size()<=v2.size())
{
temp = v1;
v1= v2;
v2 = temp;
}
int cnt1 = 0,cnt2 = v2.size()-1;
while(cnt1<v1.size()&&cnt2>=0)
{
ans.push_back(v1[cnt1++]);
if(cnt1>=v1.size())break;
ans.push_back(v1[cnt1++]);
if(cnt1>=v1.size())break;
ans.push_back(v2[cnt2--]);
if(cnt2<0)break;
}
while(cnt1<v1.size())
{
ans.push_back(v1[cnt1++]);
}
while(cnt2>=0)
{
ans.push_back(v2[cnt2--]);
}
for(int i=0;i<ans.size();i++)
{
if(i!=ans.size()-1)
printf("%05d %d %05d\n",ans[i].add,ans[i].val,ans[i+1].add);
else
{
printf("%05d %d -1\n",ans[i].add,ans[i].val);
}
}
return 0;
}
結果：
第三題：
給出每個結點的兩個孩子與內容。輸出後綴表達式。首先，把所有的孩子，除了-1外都存下來。缺的哪一個就是根節點。
再遍歷樹。注意，若結點，左右子樹都有，則後序，若無左子樹，則先序遍歷。把結果存進string，再輸出。
#include<bits/stdc++.h>
using namespace std;
struct node{
string s;
int left;
int right;
};
vector<node> v;
unordered_map<int,bool> hash1;
int N;
string ans;
string dfs(int now)
{
if(now==-1) return "";
string str;
if(v[now].right!=-1&&v[now].left!=-1)
str = "(" + dfs(v[now].left) + dfs(v[now].right) + v[now].s + ")";
else if(v[now].left==-1)
{
str = "(" + v[now].s + dfs(v[now].right) + ")";
}
return str;
}
int main()
{
scanf("%d",&N);
v.resize(N+1);
for(int i=1;i<=N;i++)
{
cin>>v[i].s>>v[i].left>>v[i].right;
if(v[i].left!=-1)
hash1[v[i].left]=true;
if(v[i].right!=-1)
hash1[v[i].right]=true;
}
int u = 1;
while(hash1[u]==true&&u<=N) u++;
ans = dfs(u);
cout<<ans;
return 0;
}
結果：
第四題
dijkstra過程爲每一輪找到與原點最近的結點加入以經確定路徑集合。而這找最近點的順序可以形成序列。考察序列是否爲dij序列。每一輪，看序列上對應的點，是否是這一步距離源點最近的點，若不是，則返回false。若是，則把該點加入已確定的點，再通過相應的邊更新其餘點距離源點的距離。直到所有點都確定了最短路徑。則返回true。
剛開始，我以爲這題應該會很容易超時。所以準備用優先隊列，查找距離源點最近點會快一點。後來發現不行。因爲不是找最近點。而是確定序列上對應點是不是這一輪的最近點。因爲，可能有距離相等值。所以後來按照普通dij，也沒超時。
還有一個更好理解的方法就是。直接dij一輪。看序列上的點是否是按照距離源點以不減的方式排列的。是的那就是true。不是就是false。
#include<bits/stdc++.h>
using namespace std;
priority_queue<int> q;
const int inf = 1<<30;
const int maxn = 1010;
int nv,ne,K;
int g[maxn][maxn];
int d[maxn];
bool vis[maxn];
vector<int> v;
bool dijkstra()
{
bool flag = true;
int cnt = 0;
fill(d,d+maxn,inf);
fill(vis,vis+maxn,false);
d[v[cnt]]=0;
for(int i=0;i<nv;i++)
{
int u = -1,minn = inf;
for(int j=1;j<=nv;j++)
{
if(vis[j]==false&&d[j]<minn)
{
u = j;
minn = d[j];
}
}
if(d[u]<d[v[cnt++]])
{
flag = false;
break;
}
if(u==-1) break;
vis[u] = true;
for(int j=1;j<=nv;j++)
{
if(vis[j]==false&&g[u][j]!=inf)
{
if(d[j]>d[u]+g[u][j])
{
d[j] = d[u]+g[u][j];
}
}
}
}
if(cnt!=nv) flag = false;
return flag;
}
int main()
{
fill(g[0],g[0]+maxn*maxn,inf);
scanf("%d%d",&nv,&ne);
v.resize(nv);
for(int i=0;i<ne;i++)
{
int u,v,dis;
scanf("%d%d%d",&u,&v,&dis);
g[u][v]=g[v][u]=dis;
}
scanf("%d",&K);
for(int i=0;i<K;i++)
{
for(int j=0;j<nv;j++)
{
scanf("%d",&v[j]);
}
if(dijkstra())
{
printf("Yes\n");
}else
{
printf("No\n");
}
}
return 0;
}
結果：
