每日总结 1.4

                                          混合牛奶

描述

造者所要付出钱的最小值。 注意: 每天农民生产的牛奶的总数对快乐的牛奶制造者来说足够的。

格式
输入格式
第 1 行:二个整数, N 和 M。 第一个数值,N,(0<= N<=2,000,000)是快乐的牛奶制造者的一天需要牛奶的数量。 第二个数值,M,(0<= M<=5,000)是他们可能从农民那买到的数目。 第 2 到 M+1 行:每行二个整数,Pi 和 Ai。 Pi(0<= Pi<=1,000) 是农民 i 牛奶的价格。 Ai(0 <= Ai <= 2,000,000)是农民 i 一天能卖给快乐的牛奶制造者的牛奶数量。

输出格式
单独的一行包含单独的一个整数，表示快乐的牛奶制造者拿到所需的牛奶所要的最小费用

样例输入 Copy

1. 100 5

2. 5 20

3. 9 40

4. 3 10

5. 8 80

6. 6 30

样例输出 Copy

630		

6 30
样例输出 Copy
630        

基本思路

求最小费用，所以可以先进行排序再来选择牛奶，

按照价格高低从低到高进行排序

这里用的是冒泡

求和时要考虑是否超过所需量

#include<stdio.h>
int main()
{
    int n,m,a[5001],b[5001],temp,price=0;
    scanf("%d%d",&n,&m);
    for(int i=1;i<=m;i++)
    {
        scanf("%d%d",&a[i],&b[i]);
    }
    for(int i=1;i<=m-1;i++)
    {
        for(int j=1;j<=m-i;j++)
        {
            if(a[j]>a[j+1])
            {
                temp=a[j];
                a[j]=a[j+1];
                a[j+1]=temp;
                temp=b[j];
                b[j]=b[j+1];
                b[j+1]=temp;
            }
        }
    }
    for(int i=1;i<=m;i++)
    {
        if(n>b[i])
        {
            n=n-b[i];
            price=b[i]*a[i]+price;
        }
        else
        {
            price=price+a[i]*n;
            break;
        }
    }
    printf("%d",price);
    return 0;
}

帮元歌找傀儡

题目描述

国服元歌的傀儡丢了，要知道元歌没了傀儡就什么也不是了，他很想知道他还能不能找到他的傀儡，好心的你可以帮帮他嘛~
测试数据多组， 矩阵n ( 1 < n < 20 ) ‘.’表示可以通行,‘*’不可以通行。

输入

输入 n，和元歌所在位置(a, b),   傀儡所在位置(c,d) 

输出

如果元歌可以找到傀儡就输出Yes 否则输出No

样例输入 复制

3
...
...
...
0 0 2 2

样例输出 复制

Yes

提示

国服元歌提醒你，有多组输入哦

主要思路还是搜索，这里对于元哥能不能到一点，我使用广度搜索，即bfs以及与回溯运用

在路上判断是否能到达，以及是否到达终点。

#include<stdio.h>
char a[20][20];
int book[20][20];
struct note
{
    int x;
    int y;
};
int main()
{
    int n,sx,sy,fx,fy,tx,ty,flag;
    int next[4][2]={{0,1},{1,0},{0,-1},{-1,0}};
    int tail,head;
    struct note que[401];
    while(~scanf("%d",&n))
    {
        for(int i=0;i<n;i++)
        {
            scanf("%s",a[i]);
        }
        scanf("%d%d%d%d",&sx,&sy,&fx,&fy);
        tail=1;
        head=1;
        que[tail].x=sx;
        que[tail].y=sy;
        tail++;
        book[sx][sy]=1;
        flag=0;
        while(head<tail)
        {
            for(int i=0;i<=3;i++)
            {
                tx=que[head].x+next[i][0];
                ty=que[head].y+next[i][1];
                if(tx<0||ty<0||tx>=n||ty>=n)
                {
                    continue;
                }
                if(tx==fx&&ty==fy)
                {
                    flag=1;
                    break;
                }
                if(a[tx][ty]=='.'&&book[tx][ty]==0)
                {
                    book[tx][ty]=1;
                    que[tail].x=tx;
                    que[tail].y=ty;
                    tail++;
                }
            }
            if(flag==1)
            {
                printf("Yes\n");
                break;
            }
            head++;
        }
        if(flag==0)
        {
            printf("No\n");
        }
        for(int i=0;i<n;i++)
        {
            for(int j=0;j<n;j++)
            {
                book[i][j]=0;
            }
        }
    }
     
    getchar();
    getchar();
    return 0;
}

还有就是对查并集的继续学习

并查集

并查集是一种树型的数据结构，用于处理一些不相交集合的合并及查询问题（即所谓的并、查）。比如说，我们可以用并查集来判断一个森林中有几棵树、某个节点是否属于某棵树等。

并查集主要由一个整型数组pre[ ]和两个函数find( )、join( )构成。
数组 pre[ ] 记录了每个点的前驱节点是谁，函数 find(x) 用于查找指定节点 x 属于哪个集合，函数 join(x,y) 用于合并两个节点 x 和 y 。

这里初略学习了

路径压缩算法

即为find（）函数的优化

当从某个节点出发去寻找它的根节点时，我们会途径一系列的节点

我们可以通过递归的方法来逐层修改返回时的某个节点的直接前驱（即pre[x]的值）。简单说来就

是将x到根节点路径上的所有点的pre（上级）都设为根节点。

以下是代码实现

int find(int x)     				
{
    if(pre[x] == x) return x;		      
    return pre[x] = find(pre[x]);	
}

一般来说，一个并查集对应三个操作：
1、初始化（ Init()函数 ）
2、查找函数（ Find()函数 ）
3、合并集合函数（ Join()函数 ）