天梯赛 2.8

L1-096 谁管谁叫爹

#include <stdio.h>
int sum(int a)
{
    int s=0;
    while(a)
    {
        s+=a%10;
        a/=10;
    }
    return s;
}
int main()
{
int n=0;
    scanf("%d",&n);
    for(int i=0;i<n;i++)
    {
        long long a,b;
        scanf("%ld %ld",&a,&b);
        int A=sum(a);int B=sum(b);
        if(a%B==0 && b%A!=0)
            printf("A\n");
         else if(b%A==0 && a%B!=0)
             printf("B\n");
        else 
            a>b?printf("A\n"):printf("B\n");
    }
    return 0;
}

L2-001 紧急救援

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#define INF 65535
struct zlh{
 int vis;//是否已经找出 
 int u;//存路程 
 int g;//存一共有几条路径 
 int ru[10][50];//ru 这个二维数组用来存路径 
 int p[10];//存若干条路径的长度 
};
int jc[500][500]={0};
int main(){
 struct zlh yu[500]={}; 
 for(int i=0;i<=499;i++)
  yu[i].g=1; 
 int a,b,m1,n1,y=0,ui[1000]={};
 scanf("%d%d%d%d",&a,&b,&m1,&n1); 
 for(int i=0;i<a;i++)
  scanf("%d",&ui[i]);
 ui[999]=ui[0];
 ui[0]=ui[m1];
 ui[m1]=ui[999];
 for(int i=1;i<=b;i++){
  int u,m,r;
  scanf("%d%d%d",&u,&m,&r);
  if(!u) u=m1;//先写了以0为起点的算法,后来发现看错了 不想改,就加了个补丁. 
  else if(u==m1) u=0;
  if(!m) m=m1;
  else if(m==m1) m=0;
  jc[u][m]=r;
  jc[m][u]=r;
 }
 for(int i=1;i<a;i++)
  for(int t=1;t<a;t++)
   jc[i][t]=!jc[i][t]||i==t?INF:jc[i][t];          
 for(int i=1;i<a;i++){
  yu[i].u=!jc[0][i]?INF:jc[0][i];
 }   
 while(++y<a){
  int min=INF,k=0;
  for(int i=1;i<a;i++){
   if(!yu[i].vis&&yu[i].u<min){
    min=yu[i].u;
    k=i;
   }    
  }    
  for(int i=1;i<a;i++){
   if(yu[i].u>jc[k][i]+min){
    yu[i].g=yu[k].g;
    yu[i].u=jc[k][i]+min;
    for(int q=1;q<=yu[k].g;q++){
     yu[i].p[q]=yu[k].p[q];
     for(int t=0;t<=yu[k].p[q];t++)
      yu[i].ru[q][t]=yu[k].ru[q][t];
     yu[i].ru[q][++yu[i].p[q]]=k;
    }    
   }
   else if(yu[i].u==jc[k][i]+min){
    for(int q=1;q<=yu[k].g;q++){
     yu[i].p[++yu[i].g]=yu[k].p[q];
     for(int t=0;t<=yu[k].p[q];t++)
      yu[i].ru[yu[i].g][t]=yu[k].ru[q][t];
     yu[i].ru[yu[i].g][++yu[i].p[yu[i].g]]=k;     
    }
   }
  }
  yu[k].vis=1;
 }
 if(!n1) n1=m1;
 printf("%d",yu[n1].g);
 int se=0,sr=0;
 for(int i=1;i<=yu[n1].g;i++){
  int gh=0;
  for(int t=0;t<=yu[n1].p[i];t++){
    gh+=ui[yu[n1].ru[i][t]];   
  }  
  gh+=ui[n1];
  
  if(gh>se){
   sr=i;
   se=gh;
  } 
 }
 printf(" %d\n",se);
 for(int i=0;i<=yu[n1].p[sr];i++){
  if(yu[n1].ru[sr][i]==0) printf("%d ",m1);
  else if(yu[n1].ru[sr][i]==m1) printf("%d ",0);
  else printf("%d ",yu[n1].ru[sr][i]);
 }
 printf("%d\n",n1==m1?0:n1);  
} 

 L2-002 链表去重

#include<math.h>
#include<stdio.h>
struct node
{
    int key,next;
}a[100010];//存放链表,值和下一个的地址
int start,n;
int firarray[100010],secarray[100010];///两个数组，分别用来存放不重复的结点的首地址，重复淘汰结点的首地址
int repeat[1000010];
int main()
{
    scanf("%d%d",&start,&n);
    for(int i=0;i<n;i++)
    {
        int q,w,e;
        scanf("%d%d%d",&q,&w,&e);
        a[q].key=w;
        a[q].next=e;
    }
    int len1,len2;//记录两个数组的长度
    len1=len2=0;
    for(int i=start;i>-1;i=a[i].next)
    {
        int key=fabs(a[i].key);
        if(repeat[key]==0)///判断这个数出现过没有，没出现过将这个数标记为1,并将地址加入firarray数组中
        {
            repeat[key]=1;
            firarray[len1++]=i;
        }
        else///出现过就将当前位置的地址加入secarray中
        {
            secarray[len2++]=i;
        }
    }
    for(int i=0;i<len1;i++)///输出，当到最后一个位置时输出-1
    {
        printf("%05d %d ",firarray[i],a[firarray[i]].key);
        if(i==len1-1)
            printf("-1\n");
        else
            printf("%05d\n",firarray[i+1]);
    }
    for(int i=0;i<len2;i++)
    {
        printf("%05d %d ",secarray[i],a[secarray[i]].key);
        if(i==len2-1)
            printf("-1\n");
        else
            printf("%05d\n",secarray[i+1]);
    }
    return 0;
}

 L2-003 月饼

#include<stdio.h> 
typedef struct Stu
{
	float k;
	float s;
	float d; 
};
int main()
{
	int i,j,n,m;
	float sum0=0,sum1=0;
	scanf("%d %d",&n,&m);
	struct Stu stu[n],stu1[n];
	for(i=0;i<n;i++)
	{
		scanf("%f",&stu[i].k);
	}
	for(i=0;i<n;i++)
	{
		scanf("%f",&stu[i].s);
		stu[i].d=stu[i].s/stu[i].k;
	}
	for(i=0;i<n-1;i++) 
	{
		for(j=i+1;j<n;j++)
		{
			if(stu[i].d<stu[j].d)
			{
				stu1[1]=stu[i];
				stu[i]=stu[j];
				stu[j]=stu1[1];
			}
		}
	}
	for(i=0;i<n;i++)
	{
		sum0+=stu[i].k;
		sum1+=stu[i].s;
		if(sum0>m)
		{
			sum0-=stu[i].k;   
			sum1-=stu[i].s;
			sum1=sum1+((float)m-sum0)*stu[i].d;
			break;
		}
		else if(sum0==m)
		{
			break;
		}
	}
	printf("%.2f\n",sum1);
	return 0;
}

L2-004 这是二叉搜索树吗？ 

 

#include<stdio.h>
#include<stdlib.h>
// 定义二叉树的节点结构体
typedef struct treeNode
{
    int data;
    struct treeNode* left;
    struct treeNode* right;
}NODE, * LPNODE;

LPNODE insert(LPNODE tree, int data); // 镜像二叉树的创建
LPNODE insert_mirror(LPNODE tree, int data);// 镜像二叉树的创建
void preOrder(LPNODE tree); // 先序遍历
void lastOrder(LPNODE tree); // 后序遍历

int n, a[1005];
int i, count = 0; // 计数
LPNODE Tree = NULL, mirror = NULL; // 二叉树和镜像二叉树
int num[1005]; // 存放数据，进行判断与输出
int flag1 = 0, flag2 = 0; // 判断序列是否为二叉树或镜像二叉树
int main()
{
    scanf("%d", &n);
    for (i = 0; i < n; i++)
    {
        scanf("%d", &a[i]);
        Tree = insert(Tree, a[i]); // 创建二叉树
        mirror = insert_mirror(mirror, a[i]); // 创建镜像二叉树
    }
    preOrder(Tree); // 先序遍历二叉树
    count = 0;
    for (i = 0; i < n; i++)
    {
        if (num[i] != a[i])
        {
            flag1 = 1;
            break;
        }
    }

    preOrder(mirror); // 先序遍历镜像二叉树
    count = 0;
    for (i = 0; i < n; i++)
    {
        if (num[i] != a[i])
        {
            flag2 = 1;
            break;
        }
    }
    if (!flag1 || !flag2)
    {
        printf("YES\n");
        if (flag1 && !flag2)
            lastOrder(mirror);
        if (flag2 && !flag1)
            lastOrder(Tree);
        if (!flag1 && !flag2)
            lastOrder(Tree);
        printf("%d", num[0]);
        for (i = 1; i < n; i++)
        {
            printf(" %d", num[i]);
        }
        printf("\n");
    }
    else
    {
        printf("NO\n");
    }
    return 0;
}

// 二叉树的创建
LPNODE insert(LPNODE tree, int data)
{
    // 如果根节点不存在，则创建根节点
    if (tree == NULL)
    {
        tree = (LPNODE)malloc(sizeof(NODE));
        tree->data = data;
        tree->left = NULL;
        tree->right = NULL;
    }
    // 如果根节点存在，则存储数据
    else
    {
        // 如果数据小于根节点，则存放至左子树
        if (data < tree->data)
            tree->left = insert(tree->left, data);
        // 如果数据大于等于根节点，则存放至右子树
        if (data >= tree->data)
            tree->right = insert(tree->right, data);
    }
    return tree;
}

// 镜像二叉树的创建
LPNODE insert_mirror(LPNODE tree, int data)
{
    // 如果根节点不存在，则创建根节点
    if (tree == NULL)
    {
        tree = (LPNODE)malloc(sizeof(NODE));
        tree->data = data;
        tree->left = NULL;
        tree->right = NULL;
    }
    // 如果根节点存在，则存储数据
    else
    {
        // 如果数据小于根节点，则存放至右子树
        if (data < tree->data)
            tree->right = insert_mirror(tree->right, data);
        // 如果数据大于等于根节点，则存放至左子树
        if (data >= tree->data)
            tree->left = insert_mirror(tree->left, data);
    }
    return tree;
}

// 先序遍历
void preOrder(LPNODE tree)
{
    if (tree != NULL)
    {
        num[count] = tree->data;
        count++;
        preOrder(tree->left);
        preOrder(tree->right);
    }
}

// 后序遍历
void lastOrder(LPNODE tree)
{
    if (tree != NULL)
    {
        lastOrder(tree->left);
        lastOrder(tree->right);
        num[count] = tree->data;
        count++;
    }
}

蓝桥杯 重合次数

#include<stdio.h>
int main()
{
    int h=6,m=13,s=22,sum=0;
    for(int i=1;i<1000000;i++)
    {
        s++;
        if(s==60)
        {
            m++;s=0;
        }
            if(s==m)sum++;
            if(m==60)
            {
                m=0;h++;
                
            }
            if(h==14&&m==36&&s==20)
            printf("%d",sum);
    }
    return 0;
}