PTA浙大版《数据结构（第2版）》题目集 参考答案（编程题）
本答案配套详解教程专栏，专栏中对每个题目答案有更详细解析，欢迎订阅专栏。
专栏链接：PTA浙大版《数据结构（第2版）》题目集 详解教程_少侠PSY的博客-CSDN博客
实例1.1 最大子列和问题 (20 分)
#include<stdio.h>
int main(){
int n,i,thissum,maxsum;
thissum=maxsum=0;
scanf("%d",&n);
int list[n];
for(i=0;i<n;i++)scanf("%d",&list[i]);
for(i=0;i<n;i++){
thissum+=list[i];
if(thissum<0)thissum=0;
else if(thissum>maxsum)maxsum=thissum;
}
printf("%d",maxsum);
return 0;
}
习题2.1 简单计算器 (20 分)
#include<stdio.h>
int main(){
int sum=0,a;
char b;
scanf("%d",&sum);
scanf("%c",&b);
while(b!='='){
scanf("%d",&a);
switch(b){
case '+':sum+=a;break;
case '-':sum-=a;break;
case '*':sum*=a;break;
case '/':
if(a!=0)sum/=a;
else{
printf("ERROR");
return 0;
}
break;
default:printf("ERROR");return 0;
}
scanf("%c",&b);
}
printf("%d",sum);
return 0;
}
习题2.2 数组循环左移 (20 分)
#include<stdio.h>
int main(){
int m,n,temp,i,j;
scanf("%d %d",&n,&m);
int a[n];
m=m%n;
for(i=0;i<n;i++)scanf("%d",&a[i]);
for(i=0;i<m;i++){
temp=a[0];
for(j=0;j<n;j++)a[j]=a[j+1];
a[n-1]=temp;
}
printf("%d",a[0]);
for(i=1;i<n;i++)printf(" %d",a[i]);
return 0;
}
习题2.3 数列求和-加强版 (20 分)
#include<stdio.h>
int main(){
int A,N,i,carry=0;//carry表示进位的数
scanf("%d %d",&A,&N);
if(N==0)printf("0");
else{
int a[N];
for(i=0;i<N;i++){
a[i]=(A*(N-i)+carry)%10;
carry=(A*(N-i)+carry)/10;
}
if(carry)printf("%d",carry);
for(i=N-1;i>=0;i--)printf("%d",a[i]);
}
return 0;
}
习题2.8 输出全排列
#include <stdio.h>
int visited[10]={
0};
int list[10];
void dfs(int n,int m){
int i;
if(m==n+1){
for(int i=1;i<=n;i++)
printf("%d",list[i]);
printf("\n");
}
else{
for(i=1;i<=n;i++){
if(!visited[i]){
list[m]=i;
visited[i]=1;
dfs(n,m+1);
visited[i]=0;
}
}
}
}
int main(){
int n;
scanf("%d", &n);
dfs(n,1);
return 0;
}
习题3.4 最长连续递增子序列
#include<stdio.h>
int main(){
int n,i,j=0,num=1,max=1;
scanf("%d",&n);
int a[n];
for(i=0;i<n;i++)scanf("%d",&a[i]);
if(n==1)printf("%d",a[0]);
else{
for(i=0;i<n-1;i++){
if(a[i]<a[i+1]){
num+=1;
if(max<num){
max=num;
j=i+1;
}
}else num=1;
}
for(i=max;i>0;i--){
printf("%d",a[j-i+1]);
if(i>1)printf(" ");
}
}
return 0;
}
习题3.6 一元多项式的乘法与加法运算
#include<stdio.h>
#include<stdlib.h>
typedef struct PolyNode* Polynomial;
struct PolyNode {
int Coef;
int Expon;
Polynomial Next;
};
typedef Polynomial PtrToPolyNode;
Polynomial Read();
void Attach(int coef, int expon, PtrToPolyNode* Rear);
Polynomial Mult(Polynomial P1, Polynomial P2);
Polynomial Add(Polynomial P1, Polynomial P2);
void PrintReslut(Polynomial P);
int main(){
Polynomial P1, P2, PM, PA;
P1 = Read();
P2 = Read();
PM = Mult(P1, P2);
PA = Add(P1, P2);
PrintReslut(PM);
PrintReslut(PA);
return 0;
}
Polynomial Read(){
Polynomial P = (Polynomial)malloc(sizeof(struct PolyNode));
P->Next = NULL;
Polynomial Rear = P, t;
int n, coef, expon;
scanf("%d", &n);
while (n--){
scanf("%d %d", &coef, &expon);
Attach(coef, expon, &Rear);
}
t = P;
P = P->Next;
free(t);
return P;
}
void Attach(int coef, int expon, PtrToPolyNode* Rear){
Polynomial P = (Polynomial)malloc(sizeof(struct PolyNode));
P->Coef = coef;
P->Expon = expon;
P->Next = NULL;
(*Rear)->Next = P;
*Rear = P;
}
Polynomial Mult(Polynomial P1, Polynomial P2){
if (!P1 || !P2) return NULL;
Polynomial P = (Polynomial)malloc(sizeof(struct PolyNode));
P->Next = NULL;
Polynomial t1 = P1, t2 = P2, Rear = P, t;
int coef, expon;
while (t2){
Attach(t1->Coef * t2->Coef, t1->Expon + t2->Expon, &Rear);
t2 = t2->Next;
}
t1 = t1->Next;
while (t1){
t2 = P2;
Rear = P;
while (t2){
coef = t1->Coef * t2->Coef;
expon = t1->Expon + t2->Expon;
while (Rear->Next && Rear->Next->Expon > expon)Rear = Rear->Next;
if (Rear->Next && Rear->Next->Expon == expon){
Rear->Next->Coef += coef;
if (Rear->Next->Coef == 0){
t = Rear->Next;
Rear->Next = t->Next;
free(t);
}
}else{
t = (Polynomial)malloc(sizeof(struct PolyNode));
t->Coef = coef;
t->Expon = expon;
t->Next = Rear->Next;
Rear->Next = t;
}
t2 = t2->Next;
}
t1 = t1->Next;
}
t = P;
P = P->Next;
free(t);
return P;
}
Polynomial Add(Polynomial P1, Polynomial P2){
Polynomial P = (Polynomial)malloc(sizeof(struct PolyNode));
P->Next = NULL;
Polynomial Rear = P, t;
while (P1 && P2){
if (P1->Expon > P2->Expon){
Attach(P1->Coef, P1->Expon, &Rear);
P1 = P1->Next;
}else if (P1->Expon < P2->Expon){
Attach(P2->Coef, P2->Expon, &Rear);
P2 = P2->Next;
}else{
if(P1->Coef+P2->Coef)
Attach(P1->Coef+P2->Coef, P2->Expon, &Rear);
P1 = P1->Next;
P2 = P2->Next;
}
}
while (P1){
Attach(P1->Coef, P1->Expon, &Rear);
P1 = P1->Next;
}
while (P2) {
Attach(P2->Coef, P2->Expon, &Rear);
P2 = P2->Next;
}
t = P;
P = P->Next;
free(t);
return P;
}
void PrintReslut(Polynomial P){
if (P == NULL) printf("0 0\n");
else{
printf("%d %d", P->Coef, P->Expon);
P = P->Next;
while (P){
printf(" %d %d", P->Coef, P->Expon);
P = P->Next;
}
printf("\n");
}
}
习题3.8 符号配对
#include <stdio.h>
#define MAXN 100
int S[MAXN], top, newline;
void push( int e );
void pop();
int token( char c );/
int check( int t );
int main() {
char c;
int t, out;
newline = 1;
top = -1;
out = 0;
while (1) {
scanf("%c", &c);
t = token(c);
switch (t) {
case 100:
out = 1;
break;
case 0:
newline = 1;
break;
default: {
newline = 0;
if (t > 10)
out = check(t);
break;
}
}
if (out)
break;
}
if (out == 1 && top == -1)
printf("YES\n");
else {
printf("NO\n");
if (out > 0) {
switch (S[top]) {
case 1:
printf("/*");
break;
case 2:
printf("{");
break;
case 3:
printf("[");
break;
case 4:
printf("(");
break;
default:
break;
}
printf("-?\n");
} else {
printf("?-");
if (t == 11)
printf("*/\n");
else
printf("%c\n", c);
}
}
return 0;
}
void push( int e ) {
S[++top] = e;
}
void pop() {
top--;
}
int token( char c ) {
int t;
if (c == '.' && newline) {
scanf("%c", &c);
t = token(c);
if (!t)
return 100;
else
return t;
}
switch (c) {
case '\n':
return 0;
case '{':
push(2);
return 2;
case '[':
push(3);
return 3;
case '(':
push(4);
return 4;
case '/':
scanf("%c", &c);
if (c == '*') {
push(1);
return 1;
} else
return token(c);
case '}':
return 12;
case ']':
return 13;
case ')':
return 14;
case '*':
scanf("%c", &c);
if (c == '/') {
return 11;
} else
return token(c);
default:
return -1;
}
}
int check( int t ) {
if (top == -1)
return -1;
if (S[top] != (t - 10))
return 1;
else {
pop();
return 0;
}
}
习题3.9 堆栈操作合法性
#include <stdio.h>
#define MAXS 101
#define MAXN 50
int S[MAXN], top, M;
int IsEmpty(){
return (top==-1)? 1:0;
}
int IsFull(){
return (top==M-1)? 1:0;
}
int push(){
if (IsFull()) return 0;
else {
S[++top] = 1; return 1; }
}
int pop(){
if (IsEmpty()) return 0;
else {
top--; return 1; }
}
int main(){
int N, i, j;
char str[MAXS];
scanf("%d %d\n", &N, &M);
for (i=0; i<N; i++) {
scanf("%s", str);
j = 0; top = -1;
while (str[j]!='\0') {
if ((str[j]=='S') && (!push())) break;
if ((str[j]=='X') && (!pop())) break;
j++;
}
if ((str[j]=='\0') && IsEmpty()) printf("YES\n");
else printf("NO\n");
}
return 0;
}
习题3.10 汉诺塔的非递归实现
#include<stdio.h>
#define MaxSize 100
typedef struct {
int N;
char A;
char B;
char C;
} ElementType;
ElementType ERROR;
typedef struct {
ElementType Data[MaxSize];
int Top;
} Stack;
void Push( Stack *PtrS, ElementType item ){
if ( PtrS->Top == MaxSize-1 ) {
printf("堆栈满");
return;
}
else {
PtrS->Data[++(PtrS->Top)] = item;
return;
}
}
ElementType Pop( Stack *PtrS ){
if ( PtrS->Top == -1 ) {
printf("堆栈空");
return ERROR;
}
else {
PtrS->Top --;
return ( PtrS->Data[PtrS->Top+1] );
}
}
void Hanoi( int n ) {
ElementType P, toPush;
Stack S;
P.N = n; P.A='a'; P.B='b'; P.C='c';
S.Top= -1;
Push(&S, P);
while ( S.Top != -1 ) {
P = Pop(&S);
if ( P.N == 1)
printf("%c -> %c\n", P.A, P.C);
else {
toPush.N = P.N - 1; toPush.A = P.B; toPush.B = P.A; toPush.C = P.C;
Push( &S, toPush );
toPush.N = 1; toPush.A = P.A; toPush.B = P.B; toPush.C = P.C;
Push( &S, toPush );
toPush.N = P.N - 1; toPush.A = P.A; toPush.B = P.C; toPush.C = P.B;
Push( &S, toPush );
}
}
}
int main(){
int n;
ERROR.N = -1;
scanf("%d", &n);
Hanoi(n);
return 0;
}
习题3.11 表达式转换
#include <stdio.h>
#include <string.h>
#define MAXL 20
char S[MAXL];
int top = -1;
typedef enum {
lparen, rparen, plus, minus, times, divide, eos, operand}
Precedence;
Precedence P ( char op ){
switch ( op ) {
case '+': return plus;
case '-': return minus;
case '*': return times;
case '/': return divide;
case '\0': return eos;
default: return operand;
}
}
void ToPostfix( char *expr ){
int i, j, L;
char pexpr[2*MAXL+2];
i = j = 0; L = strlen(expr);
while ( i<L ) {
while (isdigit(expr[i]) || (expr[i]=='.'))
pexpr[j++] = expr[i++];
if (j && isdigit(pexpr[j-1]))
pexpr[j++] = ' ';
if (i==L) break;
switch(expr[i]) {
case '(': S[++top] = '('; break;
case ')':
while (S[top]!='(') {
pexpr[j++] = S[top--];
pexpr[j++] = ' ';
if (top == -1) return;
}
top--;
break;
default:
if ( !i || (!isdigit(expr[i-1]) && (expr[i-1]!=')')) ) {
if (expr[i]=='+') break;
else if (expr[i]=='-') {
pexpr[j++] = expr[i]; break; }
}
while (top >-1 && S[top]!='(' && P(expr[i]) <= P(S[top])) {
pexpr[j++] = S[top--];
pexpr[j++] = ' ';
if (top == -1) break;
}
S[++top] = expr[i];
break;
}
i++;
}
while (top>-1) {
pexpr[j++] = S[top--];
pexpr[j++] = ' ';
}
pexpr[j-1] = '\0';
printf("%s\n", pexpr);
}
int main(){
char s[MAXL+1];
int i = 0;
scanf("%s", s);
ToPostfix(s);
return 0;
}
练习4.1 根据后序和中序遍历输出先序遍历
#include <stdio.h>
#include <stdlib.h>
#define MAXN 30
typedef struct TreeNode *Tree;
struct TreeNode {
int Element;
Tree Left;
Tree Right;
};
Tree BuildTree( int inorder[], int postorder[], int N ){
Tree T;
int p;
if (!N) return NULL;
T = (Tree)malloc(sizeof(struct TreeNode));
T->Element = postorder[N-1];
T->Left = T->Right = NULL;
for (p=0; p<N; p++)
if (inorder[p]==postorder[N-1]) break;
T->Left = BuildTree( inorder, postorder, p );
T->Right = BuildTree( inorder+p+1, postorder+p, N-p-1 );
return T;
}
void Preorder_output( Tree T ){
if (!T) return;
printf(" %d", T->Element);
Preorder_output(T->Left);
Preorder_output(T->Right);
}
int main(){
Tree T;
int inorder[MAXN], postorder[MAXN], N, i;
scanf("%d", &N);
for (i=0; i<N; i++) scanf("%d", &postorder[i]);
for (i=0; i<N; i++) scanf("%d", &inorder[i]);
T = BuildTree(inorder, postorder, N);
printf("Preorder:");
Preorder_output(T); printf("\n");
return 0;
}
练习4.2 平衡二叉树的根
#include <stdio.h>
#include <stdlib.h>
typedef struct Node *Tree;
struct Node {
int key, h;
Tree left, right;
};
int maxh( int h1, int h2 ){
return h1<h2 ? h2:h1;
}
int Height( Tree T ){
if (T) return T->h;
else return -1;
}
Tree LL( Tree K2 ){
Tree K1;
K1 = K2->left;
K2->left = K1->right;
K1->right = K2;
K2->h = maxh(Height(K2->left), Height(K2->right)) + 1;
K1->h = maxh(Height(K1->left), K2->h) + 1;
return K1;
}
Tree RR( Tree K2 ){
Tree K1;
K1 = K2->right;
K2->right = K1->left;
K1->left = K2;
K2->h = maxh(Height(K2->left), Height(K2->right)) + 1;
K1->h = maxh(Height(K1->right), K2->h) + 1;
return K1;
}
Tree LR( Tree K3 ){
Tree K1, K2;
K1 = K3->left;
K2 = K1->right;
K1->right = K2->left;
K3->left = K2->right;
K2->left = K1;
K2->right = K3;
K1->h = maxh(Height(K1->left), Height(K1->right)) + 1;
K3->h = maxh(Height(K3->left), Height(K3->right)) + 1;
K2->h = maxh(K1->h, K3->h) + 1;
return K2;
}
Tree RL( Tree K3 ){
Tree K1, K2;
K1 = K3->right;
K2 = K1->left;
K1->left = K2->right;
K3->right = K2->left;
K2->right = K1;
K2->left = K3;
K1->h = maxh(Height(K1->left), Height(K1->right)) + 1;
K3->h = maxh(Height(K3->left), Height(K3->right)) + 1;
K2->h = maxh(K1->h, K3->h) + 1;
return K2;
}
Tree Insert( int K, Tree T ){
if (!T) {
T = malloc(sizeof(struct Node));
T->key = K; T->h = 0;
T->left = T->right = NULL;
}
else {
if (K < T->key) {
T->left = Insert(K, T->left);
if (Height(T->left) - Height(T->right) > 1)
if (K < T->left->key) T = LL(T);
else T = LR(T);
}
else {
T->right = Insert(K, T->right);
if (Height(T->right) - Height(T->left) > 1)
if (K > T->right->key) T = RR(T);
else T = RL(T);
}
T->h = maxh(Height(T->left), Height(T->right)) + 1;
}
return T;
}
int main(){
int N, K, i;
Tree T = NULL;
scanf("%d", &N);
for (i=0; i<N; i++) {
scanf("%d", &K);
T = Insert(K, T);
}
printf("%d\n", T->key);
return 0;
}
练习4.3 堆中的路径
#include <stdio.h>
#define MAXN 1001
#define MINH -10001
int H[MAXN], size;
void Create (){
size = 0;
H[0] = MINH;
}
void Insert ( int X ){
int i;
for (i=++size; H[i/2] > X; i/=2)
H[i] = H[i/2];
H[i] = X;
}
int main(){
int n, m, x, i, j;
scanf("%d %d", &n, &m);
Create();
for (i=0; i<n; i++) {
scanf("%d", &x);
Insert(x);
}
for (i=0; i<m; i++) {
scanf("%d", &j);
printf("%d", H[j]);
while (j>1) {
j /= 2;
printf(" %d", H[j]);
}
printf("\n");
}
return 0;
}
习题4.5 顺序存储的二叉树的最近的公共祖先问题
#include <stdio.h>
#define MAXN 1001
int NCA( int T[], int p1, int p2){
int p;
while (p1 != p2) {
if (p1 > p2) {
p=p1; p1=p2; p2=p; }
while (p2>p1) p2/=2;
}
return p1;
}
int main(){
int n, i, T[MAXN];
int p1, p2, p;
T[0] = 0;
scanf("%d", &n);
for (i=1; i<=n; i++) scanf("%d", &T[i]);
scanf("%d %d", &p1, &p2);
if (!T[p1]) printf("ERROR: T[%d] is NULL\n", p1);
else if (!T[p2]) printf("ERROR: T[%d] is NULL\n", p2);
else {
p = NCA(T, p1, p2);
printf("%d %d\n", p, T[p]);
}
return 0;
}
习题5.13 词频统计
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef enum {
false, true} bool;
#define MAXTable 50653
#define KEYLENGTH 15
typedef char ElementType[KEYLENGTH+1];
typedef int Index;
typedef struct LNode *PtrToLNode;
struct LNode {
ElementType Data;
int Count;
PtrToLNode Next;
};
typedef PtrToLNode Position;
typedef PtrToLNode List;
typedef struct TblNode *HashTable;
struct TblNode {
int TableSize;
List Heads;
};
HashTable CreateTable(){
HashTable H;
int i;
H = (HashTable)malloc(sizeof(struct TblNode));
H->TableSize = MAXTable;
H->Heads = (List)malloc(H->TableSize*sizeof(struct LNode));
for( i=0; i<H->TableSize; i++ ) {
H->Heads[i].Data[0] = '\0';
H->Heads[i].Count = 0;
H->Heads[i].Next = NULL;
}
return H;
}
int V ( char c ){
if (c>='0' && c<='9') return (c-'0');
if (c=='_') return 36;
return (c-'a'+10);
}
int Hash( ElementType Key ){
int i, h = 0;
for (i=0; i<3; i++) {
if (Key[i]=='\0') {
h*=37;
if (i<2) h*=37;
break;
}
else h = h*37 + V(Key[i]);
}
return h;
}
bool IsWordChar( char c ){
if ( (c>='a'&& c<='z') || (c>='A'&& c<='Z') || (c>='0'&& c<='9')|| (c == '_') )
return true;
else
return false;
}
#define MAXWORDLEN 80
int GetAWord( ElementType word ){
char tempword[MAXWORDLEN+1], c;
int len = 0;
scanf("%c", &c);
while( c!='#' ){
if( IsWordChar(c) ) {
if (c>='A' && c<='Z') c = c-'A'+'a';
tempword[len++] = c;
}
scanf("%c", &c);
if( len && !IsWordChar(c) )
break;
}
if (c=='#') return -1;
tempword[len] = '\0';
if( len>KEYLENGTH ){
tempword[KEYLENGTH] = '\0';
len = KEYLENGTH;
}
strcpy(word, tempword);
return len;
}
void Show( HashTable H, double percent ){
int diffwordcount = 0;
int maxf = 0;
Position L;
int i, j, k, lowerbound, count = 0;
for( i=0; i<H->TableSize; i++ ) {
diffwordcount += H->Heads[i].Count;
L = H->Heads[i].Next;
while( L ){
if( maxf<L->Count ) maxf = L->Count;
L = L->Next;
}
}
printf("%d\n", diffwordcount);
lowerbound = (int)((double)diffwordcount * percent);
count = 0;
for( j=maxf; j>=1; j-- ) {
for( k=0; k<H->TableSize; k++ ) {
L = H->Heads[k].Next;
while( L ){
if( j==L->Count ) {
printf("%d:%s\n", L->Count, L->Data);
count++;
}
if (count == lowerbound) return;
L = L->Next;
}
}
}
}
Position Find( HashTable H, ElementType Key ){
Position P;
Index Pos;
Pos = Hash( Key );
P = H->Heads[Pos].Next;
while( P && strcmp(P->Data, Key) )
P = P->Next;
return P;
}
void InsertAndCount( HashTable H, ElementType Key ){
Position P, NewCell;
Index Pos;
P = Find( H, Key );
if ( !P ) {
NewCell = (Position)malloc(sizeof(struct LNode));
strcpy(NewCell->Data, Key);
NewCell->Count = 1;
Pos = Hash( Key );
H->Heads[Pos].Count++;
P = H->Heads+Pos;
while (P->Next && strcmp(P->Next->Data, Key)<0) P = P->Next;
NewCell->Next = P->Next;
P->Next = NewCell;
}
else {
P->Count++;
}
}
void DestroyTable( HashTable H ){
int i;
Position P, Tmp;
for( i=0; i<H->TableSize; i++ ) {
P = H->Heads[i].Next;
while( P ) {
Tmp = P->Next;
free( P );
P = Tmp;
}
}
free( H->Heads );
free( H );
}
int main(){
HashTable H;
ElementType word;
int length;
H = CreateTable();
while(1){
length = GetAWord( word );
if( length>0 ){
InsertAndCount( H, word );
}
else break;
}
Show( H, 10.0/100 );
DestroyTable( H );
return 0;
}
实例6.1 六度空间
#include<stdio.h>
#include<stdlib.h>
#define MaxVertexNum 1000
#define ERROR -1
typedef enum {
false, true} bool;
typedef int Vertex;
typedef Vertex ElementType;
typedef int Position;
struct QNode {
ElementType *Data;
Position Front, Rear;
int MaxSize;
};
typedef struct QNode *Queue;
Queue CreateQueue( int MaxSize ){
Queue Q = (Queue)malloc(sizeof(struct QNode));
Q->Data = (ElementType *)malloc(MaxSize * sizeof(ElementType));
Q->Front = Q->Rear = -1;
Q->MaxSize = MaxSize;
return Q;
}
bool IsFull( Queue Q ){
return ((Q->Rear+1)%Q->MaxSize == Q->Front);
}
bool AddQ( Queue Q, ElementType X ){
if ( IsFull(Q) ) {
printf("队列满");
return false;
}
else {
Q->Rear = (Q->Rear+1)%Q->MaxSize;
Q->Data[Q->Rear] = X;
return true;
}
}
bool IsEmpty( Queue Q ){
return (Q->Front == Q->Rear);
}
ElementType DeleteQ( Queue Q ){
if ( IsEmpty(Q) ) {
printf("队列空");
return ERROR;
}
else {
Q->Front =(Q->Front+1)%Q->MaxSize;
return Q->Data[Q->Front];
}
}
typedef struct ENode *PtrToENode;
struct ENode{
Vertex V1, V2;
};
typedef PtrToENode Edge;
typedef struct AdjVNode *PtrToAdjVNode;
struct AdjVNode{
Vertex AdjV;
PtrToAdjVNode Next;
};
typedef struct Vnode{
PtrToAdjVNode FirstEdge;
} AdjList[MaxVertexNum];
typedef struct GNode *PtrToGNode;
struct GNode{
int Nv;
int Ne;
AdjList G;
};
typedef PtrToGNode LGraph;
#define SIX 6
int Visited[MaxVertexNum];
LGraph CreateGraph( int VertexNum ){
Vertex V;
LGraph Graph;
Graph = (LGraph)malloc( sizeof(struct GNode) );
Graph->Nv = VertexNum;
Graph->Ne = 0;
for (V=0; V<Graph->Nv; V++)
Graph->G[V].FirstEdge = NULL;
return Graph;
}
void InsertEdge( LGraph Graph, Edge E ){
PtrToAdjVNode NewNode;
NewNode = (PtrToAdjVNode)malloc(sizeof(struct AdjVNode));
NewNode->AdjV = E->V2;
NewNode->Next = Graph->G[E->V1].FirstEdge;
Graph->G[E->V1].FirstEdge = NewNode;
NewNode = (PtrToAdjVNode)malloc(sizeof(struct AdjVNode));
NewNode->AdjV = E->V1;
NewNode->Next = Graph->G[E->V2].FirstEdge;
Graph->G[E->V2].FirstEdge = NewNode;
}
LGraph BuildGraph(){
LGraph Graph;
Edge E;
int Nv, i;
scanf("%d", &Nv);
Graph = CreateGraph(Nv);
scanf("%d", &(Graph->Ne));
if ( Graph->Ne != 0 ) {
E = (Edge)malloc( sizeof(struct ENode) );
for (i=0; i<Graph->Ne; i++) {
scanf("%d %d", &E->V1, &E->V2);
E->V1--; E->V2--;
InsertEdge( Graph, E );
}
}
return Graph;
}
void InitializeVisited( int Nv ){
Vertex V;
for ( V=0; V<Nv; V++ )
Visited[V] = false;
}
int SDS_BFS( LGraph Graph, Vertex S ){
Queue Q;
Vertex V, Last, Tail;
PtrToAdjVNode W;
int Count, Level;
Q = CreateQueue( MaxVertexNum );
Visited[S] = true;
Count = 1;
Level = 0;
Last = S;
AddQ (Q, S);
while ( !IsEmpty(Q) ) {
V = DeleteQ(Q);
for( W=Graph->G[V].FirstEdge; W; W=W->Next ) {
if ( !Visited[W->AdjV] ) {
Visited[W->AdjV] = true;
Count++;
Tail = W->AdjV;
AddQ (Q, W->AdjV);
}
}
if ( V==Last ) {
Level++;
Last = Tail;
}
if ( Level==SIX ) break;
}
return Count;
}
void Six_Degrees_of_Separation( LGraph Graph ) {
Vertex V;
int count;
for( V=0; V<Graph->Nv; V++ ) {
InitializeVisited( Graph->Nv );
count = SDS_BFS( Graph, V );
printf("%d: %.2f%%\n", V+1, 100.0*(double)count/(double)Graph->Nv);
}
}
int main(){
LGraph G = BuildGraph();
Six_Degrees_of_Separation(G);
return 0;
}
练习7.1 排序
#include <stdio.h>
#define MAXN 100000
int A[MAXN];
void Insertion_Sort( int A[], int N ) {
int P, i, Tmp;
for ( P=1; P<N; P++ ) {
Tmp = A[P];
for ( i=P; i>0 && A[i-1]>Tmp; i-- )
A[i] = A[i-1];
A[i] = Tmp;
}
}
int main(){
int N, i;
scanf("%d", &N);
for (i=0; i<N; i++)
scanf("%d", &A[i]);
Insertion_Sort(A, N);
printf("%d", A[0]);
for (i=1; i<N; i++)
printf(" %d", A[i]);
printf("\n");
return 0;
}
习题8.1 银行排队问题之单队列多窗口服务
#include <stdio.h>
#include <stdlib.h>
#define MAXN 1000
#define MaxWindow 10
#define MaxProc 60
typedef enum{
false, true} bool;
typedef struct People ElementType;
struct People {
int T;
int P;
};
typedef int Position;
struct QNode {
ElementType *Data;
Position Front, Rear;
int MaxSize;
};
typedef struct QNode *Queue;
Queue CreateQueue( int MaxSize );
bool IsFull( Queue Q );
bool AddQ( Queue Q, ElementType X );
bool IsEmpty( Queue Q );
ElementType DeleteQ( Queue Q );
int FindNextWindow( int W[], int K, int *WaitTime ){
int WinAvail;
int MinW = MaxProc+1;
int i;
for ( i=0; i<K; i++ )
if ( W[i] < MinW ) {
MinW = W[i]; WinAvail = i;
}
*WaitTime = MinW;
for ( i=0; i<K; i++ )
W[i] -= MinW;
return WinAvail;
}
void QueueingAtBank( Queue Q, int N ){
struct People Next;
int K;
int TotalTime;
int CurrentTime;
int Window[MaxWindow];
int WaitTime;
int WinAvail;
int i, j;
int MaxWait;
int cnt[MaxWindow];
scanf("%d", &K);
for ( i=0; i<K; i++ ) {
Window[i] = 0;
cnt[i] = 0;
}
TotalTime = CurrentTime = 0;
MaxWait = 0;
while ( !IsEmpty(Q) ) {
WinAvail = FindNextWindow( Window, K, &WaitTime );
CurrentTime += WaitTime;
Next = DeleteQ(Q);
if ( CurrentTime >= Next.T ) {
TotalTime += (CurrentTime - Next.T);
if ((CurrentTime - Next.T)>MaxWait)
MaxWait = (CurrentTime - Next.T);
}
else {
WaitTime = Next.T - CurrentTime;
for ( j=0; j<K; j++ ) {
Window[j] -= WaitTime;
if ( Window[j] <= 0 ) {
Window[j] = 0;
if (j < WinAvail) WinAvail = j;
}
}
CurrentTime = Next.T;
}
Window[WinAvail] = Next.P;
cnt[WinAvail]++;
}
WaitTime = 0;
for (i=0; i<K; i++)
if (Window[i]>WaitTime) WaitTime = Window[i];
CurrentTime += WaitTime;
printf("%.1f %d %d\n", ((double)TotalTime/(double)N), MaxWait, CurrentTime);
printf("%d", cnt[0]);
for( i=1; i<K; i++) printf(" %d", cnt[i]);
printf("\n");
}
int main(){
int N;
Queue Q;
int i;
ElementType X;
scanf("%d", &N);
Q = CreateQueue(N+1);
for ( i=0; i<N; i++ ) {
scanf("%d %d", &X.T, &X.P);
if (X.P > MaxProc) X.P = MaxProc;
AddQ(Q, X);
}
QueueingAtBank(Q, N);
return 0;
}
Queue CreateQueue( int MaxSize ){
Queue Q = (Queue)malloc(sizeof(struct QNode));
Q->Data = (ElementType *)malloc(MaxSize * sizeof(ElementType));
Q->Front = Q->Rear = 0;
Q->MaxSize = MaxSize;
return Q;
}
bool IsFull( Queue Q ){
return ((Q->Rear+1)%Q->MaxSize == Q->Front);
}
bool AddQ( Queue Q, ElementType X ){
if ( IsFull(Q) ) {
printf("队列满");
return false;
}
else {
Q->Rear = (Q->Rear+1)%Q->MaxSize;
Q->Data[Q->Rear] = X;
return true;
}
}
bool IsEmpty( Queue Q ){
return (Q->Front == Q->Rear);
}
ElementType DeleteQ( Queue Q ){
Q->Front =(Q->Front+1)%Q->MaxSize;
return Q->Data[Q->Front];
}
习题8.2 银行排队问题之单队列多窗口加VIP服务
#include <stdio.h>
#include <stdlib.h>
#define MAXN 1000
#define MaxWindow 10
#define MaxProc 60
typedef enum {
false, true} bool;
typedef struct People ElementType;
struct People {
int T;
int P;
int VIP;
};
typedef int Position;
struct QNode {
ElementType *Data;
Position Front, Rear;
int MaxSize;
Position VIPFront, VIPRear;
int *VIPCustomer;
int VIPSize;
};
typedef struct QNode *Queue;
bool VIPIsFull(Queue Q);
bool AddVIP(Queue Q, Position P);
bool VIPIsEmpty(Queue Q);
ElementType DeleteVIP(Queue Q);
Queue CreateQueue(int MaxSize);
bool IsFull(Queue Q);
bool AddQ(Queue Q, ElementType X);
bool IsEmpty(Queue Q);
ElementType DeleteQ(Queue Q);
Queue CreateQueue(int MaxSize)
{
Queue Q = (Queue)malloc(sizeof(struct QNode));
Q->Data = (ElementType *)malloc(MaxSize * sizeof(ElementType));
Q->Front = Q->Rear = 0;
Q->MaxSize = MaxSize;
Q->VIPCustomer = (int *)malloc(MaxSize * sizeof(int));
Q->VIPFront = Q->VIPRear = 0;
Q->VIPSize = 0;
return Q;
}
bool VIPIsFull(Queue Q)
{
return (Q->VIPSize == (Q->MaxSize - 1));
}
bool AddVIP(Queue Q, Position P)
{
if (VIPIsFull(Q)) {
printf("VIP队列满");
return false;
} else {
Q->VIPRear = (Q->VIPRear + 1) % Q->MaxSize;
Q->VIPCustomer[Q->VIPRear] = P;
Q->VIPSize++;
return true;
}
}
bool IsFull(Queue Q)
{
return ((Q->Rear + 1) % Q->MaxSize == Q->Front);
}
bool AddQ(Queue Q, ElementType X)
{
if (IsFull(Q)) {
printf("队列满");
return false;
} else {
Q->Rear = (Q->Rear + 1) % Q->MaxSize;
Q->Data[Q->Rear] = X;
if (X.VIP == 1) return AddVIP(Q, Q->Rear);
else return true;
}
}
bool IsEmpty(Queue Q)
{
return (Q->Front == Q->Rear);
}
ElementType DeleteQ(Queue Q)
{
ElementType X;
while (!IsEmpty(Q) && (Q->Data[(Q->Front + 1) % Q->MaxSize].VIP == -1))
Q->Front = (Q->Front + 1) % Q->MaxSize;
if (IsEmpty(Q)) {
X.T = -1;
return X;
}
Q->Front = (Q->Front + 1) % Q->MaxSize;
if (Q->Data[Q->Front].VIP == 1)
X = DeleteVIP(Q);
else
X = Q->Data[Q->Front];
return X;
}
bool VIPIsEmpty(Queue Q)
{
return (Q->VIPSize == 0);
}
ElementType DeleteVIP(Queue Q)
{
ElementType X;
Position P;
if (!VIPIsEmpty(Q)) {
Q->VIPFront = (Q->VIPFront + 1) % Q->MaxSize;
P = Q->VIPCustomer[Q->VIPFront];
Q->VIPSize--;
Q->Data[P].VIP = -1;
X = Q->Data[P];
} else
X = DeleteQ(Q);
return X;
}
bool IsVipHere(Queue Q, int CurrentTime)
{
Position P;
if (VIPIsEmpty(Q)) return false;
P = Q->VIPCustomer[(Q->VIPFront + 1) % Q->MaxSize];
if (Q->Data[P].T > CurrentTime) return false;
else return true;
}
int FindNextWindow(int W[], int K, int *WaitTime)
{
int WinAvail;
int MinW = MaxProc + 1;
int i;
for (i = 0; i < K; i++)
if (W[i] < MinW) {
MinW = W[i];
WinAvail = i;
}
*WaitTime = MinW;
for (i = 0; i < K; i++)
W[i] -= MinW;
return WinAvail;
}
void QueueingAtBank(Queue Q, int N)
{
struct People Next;
int K;
int TotalTime;
int CurrentTime;
int Window[MaxWindow];
int WaitTime;
int WinAvail;
int i, j;
int MaxWait;
int cnt[MaxWindow];
int VIPWindow;
scanf("%d %d", &K, &VIPWindow);
for (i = 0; i < K; i++) {
Window[i] = 0;
cnt[i] = 0;
}
TotalTime = CurrentTime = 0;
MaxWait = 0;
while (!IsEmpty(Q)) {
WinAvail = FindNextWindow(Window, K, &WaitTime);
CurrentTime += WaitTime;
if ((WinAvail == VIPWindow) && (IsVipHere(Q, CurrentTime)))
Next = DeleteVIP(Q);
else
Next = DeleteQ(Q);
if (Next.VIP && (Window[VIPWindow] == 0)) WinAvail = VIPWindow;
if (Next.T == -1) break;
if (CurrentTime >= Next.T) {
TotalTime += (CurrentTime - Next.T);
if ((CurrentTime - Next.T) > MaxWait)
MaxWait = (CurrentTime - Next.T);
} else {
WaitTime = Next.T - CurrentTime;
for (j = 0; j < K; j++) {
Window[j] -= WaitTime;
if (Window[j] < 0) {
Window[j] = 0;
if (j < WinAvail) WinAvail = j;
}
}
CurrentTime = Next.T;
}
if (Next.VIP && (Window[VIPWindow] == 0)) WinAvail = VIPWindow;
Window[WinAvail] = Next.P;
cnt[WinAvail]++;
}
WaitTime = 0;
for (i = 0; i < K; i++)
if (Window[i] > WaitTime) WaitTime = Window[i];
CurrentTime += WaitTime;
printf("%.1f %d %d\n", ((double)TotalTime / (double)N), MaxWait, CurrentTime);
printf("%d", cnt[0]);
for (i = 1; i < K; i++) printf(" %d", cnt[i]);
printf("\n");
}
int main()
{
int N;
Queue Q;
int i;
ElementType X;
scanf("%d", &N);
Q = CreateQueue(N + 1);
for (i = 0; i < N; i++) {
scanf("%d %d %d", &X.T, &X.P, &X.VIP);
if (X.P > MaxProc) X.P = MaxProc;
AddQ(Q, X);
}
QueueingAtBank(Q, N);
return 0;
}
习题8.3 银行排队问题之单窗口“夹塞” 版
#include <stdio.h>
#include <malloc.h>
#include <string.h>
#define MaxProc 60
#define MAXTEAM 100
#define MAXCHAR 3
#define MAXNAME 26426
struct People {
char Name[MAXCHAR+1];
int T;
int P;
};
struct TeamQueueRecord {
int Tfront;
int Trear;
int Tsize;
struct People *Customer;
};
typedef struct TeamQueueRecord *TeamQueue;
struct QueueRecord {
int front;
int rear;
int size;
TeamQueue TeamQ;
};
typedef struct QueueRecord *Queue;
int Team[MAXNAME];
struct TeamNode {
int Position;
int Size;
} TeamInfo[MAXTEAM];
int NameHash( char name[] )
{
int i, j;
i = name[0] - 'A';
j = 1;
while (name[j]!='\0')
i = (i<<5) + name[j++] - 'A';
return i;
}
int Read_and_Set_Teams( int M )
{
int L, MaxL;
int i, j;
char name[MAXCHAR+1];
for (i=0; i<MAXNAME; i++)
Team[i] = -1;
MaxL = 0;
for (i=0; i<M; i++) {
scanf("%d ", &L);
if (L > MaxL) MaxL = L;
for (j=0; j<L; j++) {
scanf("%s", name);
Team[NameHash(name)] = i;
}
}
for (i=0; i<M; i++)
TeamInfo[i].Size = 0;
return MaxL;
}
Queue CreateQueue( int MaxQSize, int MaxTSize )
{
Queue Q;
int i;
Q = malloc( sizeof( struct QueueRecord ) );
Q->TeamQ = malloc( sizeof( struct TeamQueueRecord ) * MaxTSize );
Q->size = 0;
Q->front = 0;
Q->rear = -1;
for ( i=0; i<MaxTSize; i++ ) {
Q->TeamQ[i].Customer =
malloc( sizeof( struct People ) * MaxQSize );
Q->TeamQ[i].Tsize = 0;
Q->TeamQ[i].Tfront = 0;
Q->TeamQ[i].Trear = -1;
}
return Q;
}
void AddQ( Queue Q, struct People X )
{
int i, pos, r;
if ( X.P > MaxProc ) X.P = MaxProc;
i = Team[NameHash(X.Name)];
if ( (i == -1) || (!TeamInfo[i].Size) ) {
Q->rear++;
r = ++Q->TeamQ[Q->rear].Trear;
Q->TeamQ[Q->rear].Customer[r].T = X.T;
Q->TeamQ[Q->rear].Customer[r].P = X.P;
strcpy(Q->TeamQ[Q->rear].Customer[r].Name, X.Name);
Q->TeamQ[Q->rear].Tsize++;
Q->size++;
if ( i != -1 ) {
TeamInfo[i].Position = Q->rear;
TeamInfo[i].Size++;
}
}
else {
pos = TeamInfo[i].Position;
r = ++Q->TeamQ[pos].Trear;
Q->TeamQ[pos].Customer[r].T = X.T;
Q->TeamQ[pos].Customer[r].P = X.P;
strcpy(Q->TeamQ[pos].Customer[r].Name, X.Name);
Q->TeamQ[pos].Tsize++;
TeamInfo[i].Size++;
}
}
struct People FrontQ( Queue Q )
{
struct People X;
int f;
f = Q->TeamQ[Q->front].Tfront;
X.T = Q->TeamQ[Q->front].Customer[f].T;
X.P = Q->TeamQ[Q->front].Customer[f].P;
strcpy(X.Name, Q->TeamQ[Q->front].Customer[f].Name);
return X;
}
void DeleteQ( Queue Q )
{
int i, f;
f = Q->TeamQ[Q->front].Tfront;
Q->TeamQ[Q->front].Tfront++;
Q->TeamQ[Q->front].Tsize--;
i = Team[NameHash(Q->TeamQ[Q->front].Customer[f].Name)];
if ( i != -1 ) TeamInfo[i].Size--;
if ( !Q->TeamQ[Q->front].Tsize ) {
Q->front++;
Q->size--;
}
}
int IsEmpty( Queue Q )
{
return ( Q->size == 0 );
}
struct People Enter( int *i )
{
struct People X;
char c;
if ((*i)) {
scanf("%s %d %d%c", X.Name, &X.T, &X.P, &c);
(*i)--;
}
else X.T = -1;
return X;
}
double QueueingAtBank( Queue Q, int N )
{
struct People Next, Wait;
int TotalTime, CurrentTime;
int i = N;
TotalTime = CurrentTime = 0;
Wait = Enter( &i );
AddQ( Q, Wait );
if (!i) {
Next = FrontQ(Q);
printf("%s\n", Next.Name);
return 0.0;
}
else Wait = Enter( &i );
while ( !IsEmpty(Q) || (Wait.T >= 0) ) {
if ( !IsEmpty(Q) ) {
Next = FrontQ(Q);
printf("%s\n", Next.Name);
if ( CurrentTime >= Next.T )
TotalTime += (CurrentTime - Next.T);
else
CurrentTime = Next.T;
CurrentTime += Next.P;
while ( (Wait.T >= 0) && (Wait.T <= CurrentTime) ) {
AddQ( Q, Wait );
Wait = Enter( &i );
}
DeleteQ(Q);
}
else {
AddQ( Q, Wait );
Wait = Enter( &i );
}
}
return ((double)TotalTime/(double)N);
}
int main()
{
int N, M, MaxQSize;
Queue Q;
scanf("%d %d\n", &N, &M);
MaxQSize = Read_and_Set_Teams(M);
Q = CreateQueue( MaxQSize, N );
printf("%.1lf\n", QueueingAtBank( Q, N ));
return 0;
}
习题8.4 畅通工程之最低成本建设问题
#include <stdio.h>
#include <stdlib.h>
typedef enum {
false, true} bool;
#define MaxVertexNum 1000
typedef int Vertex;
typedef int WeightType;
typedef struct ENode *PtrToENode;
struct ENode {
Vertex V1, V2;
WeightType Weight;
};
typedef PtrToENode Edge;
typedef struct AdjVNode *PtrToAdjVNode;
struct AdjVNode {
Vertex AdjV;
WeightType Weight;
PtrToAdjVNode Next;
};
typedef struct Vnode {
PtrToAdjVNode FirstEdge;
} AdjList[MaxVertexNum];
typedef struct GNode *PtrToGNode;
struct GNode {
int Nv;
int Ne;
AdjList G;
};
typedef PtrToGNode LGraph;
LGraph CreateGraph(int VertexNum) {
Vertex V;
LGraph Graph;
Graph = (LGraph)malloc(sizeof(struct GNode));
Graph->Nv = VertexNum;
Graph->Ne = 0;
for (V = 0; V < Graph->Nv; V++)
Graph->G[V].FirstEdge = NULL;
return Graph;
}
void InsertEdge(LGraph Graph, Edge E) {
PtrToAdjVNode NewNode;
NewNode = (PtrToAdjVNode)malloc(sizeof(struct AdjVNode));
NewNode->AdjV = E->V2;
NewNode->Weight = E->Weight;
NewNode->Next = Graph->G[E->V1].FirstEdge;
Graph->G[E->V1].FirstEdge = NewNode;
NewNode = (PtrToAdjVNode)malloc(sizeof(struct AdjVNode));
NewNode->AdjV = E->V1;
NewNode->Weight = E->Weight;
NewNode->Next = Graph->G[E->V2].FirstEdge;
Graph->G[E->V2].FirstEdge = NewNode;
}
LGraph BuildGraph() {
LGraph Graph;
Edge E;
int Nv, i;
scanf("%d", &Nv);
Graph = CreateGraph(Nv);
scanf("%d", &(Graph->Ne));
if (Graph->Ne != 0) {
E = (Edge)malloc(sizeof(struct ENode));
for (i = 0; i < Graph->Ne; i++) {
scanf("%d %d %d", &E->V1, &E->V2, &E->Weight);
E->V1--;
E->V2--;
InsertEdge(Graph, E);
}
}
return Graph;
}
void PercDown(Edge ESet, int p, int N) {
int Parent, Child;
struct ENode X;
X = ESet[p];
for (Parent = p; (Parent * 2 + 1) < N; Parent = Child) {
Child = Parent * 2 + 1;
if ((Child != N - 1) && (ESet[Child].Weight > ESet[Child + 1].Weight))
Child++;
if (X.Weight <= ESet[Child].Weight)
break;
else
ESet[Parent] = ESet[Child];
}
ESet[Parent] = X;
}
void InitializeESet(LGraph Graph, Edge ESet) {
Vertex V;
PtrToAdjVNode W;
int ECount;
ECount = 0;
for (V = 0; V < Graph->Nv; V++) {
for (W = Graph->G[V].FirstEdge; W; W = W->Next) {
if (V < W->AdjV) {
ESet[ECount].V1 = V;
ESet[ECount].V2 = W->AdjV;
ESet[ECount++].Weight = W->Weight;
}
}
}
for (ECount = Graph->Ne / 2; ECount >= 0; ECount--)
PercDown(ESet, ECount, Graph->Ne);
}
void Swap(Edge a, Edge b) {
struct ENode t;
t = *a;
*a = *b;
*b = t;
}
int GetEdge(Edge ESet, int CurrentSize) {
Swap(&ESet[0], &ESet[CurrentSize - 1]);
PercDown(ESet, 0, CurrentSize - 1);
return CurrentSize - 1;
}
typedef Vertex ElementType;
typedef int SetName;
typedef ElementType SetType[MaxVertexNum];
void InitializeVSet(SetType S, int N) {
int i;
for (i = 0; i < N; i++)
S[i] = -1;
}
SetName Find(SetType S, ElementType X) {
if (S[X] < 0)
return X;
else
return S[X] = Find(S, S[X]);
}
void Union(SetType S, SetName Root1, SetName Root2) {
if (S[Root2] < S[Root1]) {
S[Root2] += S[Root1];
S[Root1] = Root2;
} else {
S[Root1] += S[Root2];
S[Root2] = Root1;
}
}
bool CheckCycle(SetType VSet, Vertex V1, Vertex V2) {
Vertex Root1, Root2;
Root1 = Find(VSet, V1);
Root2 = Find(VSet, V2);
if (Root1 == Root2)
return false;
else {
Union(VSet, Root1, Root2);
return true;
}
}
int Kruskal(LGraph Graph) {
WeightType TotalWeight;
int ECount, NextEdge;
SetType VSet;
Edge ESet;
InitializeVSet(VSet, Graph->Nv);
ESet = (Edge)malloc(sizeof(struct ENode) * Graph->Ne);
InitializeESet(Graph, ESet);
TotalWeight = 0;
ECount = 0;
NextEdge = Graph->Ne;
while (ECount < Graph->Nv - 1) {
NextEdge = GetEdge(ESet, NextEdge);
if (NextEdge < 0)
break;
if (CheckCycle(VSet, ESet[NextEdge].V1, ESet[NextEdge].V2) == true) {
TotalWeight += ESet[NextEdge].Weight;
ECount++;
}
}
if (ECount < Graph->Nv - 1)
TotalWeight = -1;
return TotalWeight;
}
int main() {
int w;
LGraph G = BuildGraph();
w = Kruskal(G);
if (w == -1)
printf("Impossible\n");
else
printf("%d\n", w);
return 0;
}
习题8.5 畅通工程之局部最小花费问题
#include <stdio.h>
#define MAXN 101
#define INF 1000000000
int belongto[MAXN], newcost[MAXN][MAXN], cost[MAXN][MAXN];
int data[MAXN][MAXN];
int n, newn;
int min(int a, int b) {
return (a < b) ? a : b;
}
long prim(int n, int mat[][MAXN]) {
int min[MAXN];
long ret = 0;
int v[MAXN], i, j, k;
for (i = 0; i < n; i++) {
min[i] = INF;
v[i] = 0;
}
for (min[j = 0] = 0; j < n; j++) {
for (k = -1, i = 0; i < n; i++) {
if (!v[i] && (k == -1 || min[i] < min[k])) {
k = i;
}
}
v[k] = 1;
ret += min[k];
for (i = 0; i < n; i++) {
if (!v[i] && mat[k][i] < min[i]) {
min[i] = mat[k][i];
}
}
}
return ret;
}
void dummy() {
int i, j, temp;
for (i = 0; i != newn; ++i) {
for (j = 0; j != newn; ++j) newcost[i][j] = INF;
}
for (i = 0; i != n; ++i) --belongto[i];
for (i = 0; i != n; ++i) {
for (j = 0; j != n; ++j) {
temp = min(cost[i][j], newcost[belongto[i]][belongto[j]]);
newcost[belongto[i]][belongto[j]] = newcost[belongto[j]][belongto[i]] = temp;
}
}
}
int findComponents(int n, int mat[][MAXN], int *id) {
int ret, k, i, j, m;
for (k = 0; k < n; id[k++] = 0);
for (ret = k = 0; k < n; k++) {
if (!id[k]) {
for (id[k] = -1, ret++, m = 1; m;) {
for (m = i = 0; i < n; i++) {
if (id[i] == -1) {
for (m++, id[i] = ret, j = 0; j < n; j++) {
if (!id[j] && mat[i][j]) {
id[j] = -1;
}
}
}
}
}
}
}
return ret;
}
int main() {
int i;
scanf("%d", &n);
for (i = 0; i != n * (n - 1) / 2; ++i) {
int x, y, t, link;
scanf("%d %d %d %d", &x, &y, &t, &link);
--x;
--y;
cost[x][y] = cost[y][x] = t;
if (link) data[x][y] = data[y][x] = 1;
else data[x][y] = data[y][x] = 0;
}
newn = findComponents(n, data, belongto);
dummy();
printf("%ld\n", prim(newn, newcost) % INF);
return 0;
}