25th Training

最新推荐文章于 2024-08-19 10:06:24 发布

程序员的冷浪漫

最新推荐文章于 2024-08-19 10:06:24 发布

阅读量857

点赞数

分类专栏： 20130909湖南AU集训_OneMonth

本文链接：https://blog.csdn.net/sunquana/article/details/12260889

版权

20130909湖南AU集训_OneMonth 专栏收录该内容

19 篇文章 0 订阅

订阅专栏

HNAU 25th Training Problem

第 25次训练 2013 /10 /04 AM

A.模拟 poj 2317
B.递推 poj 1090 Chain 递推 + 大数加法

C.数学 poj 1761

D.搜索 poj 1680
E.贪心 poj 1828
F.图论 poj 1719
G.高精度 poj 1131
H.动态规划 poj 1062

E.贪心统计所有猴子中右上角（包括边界）没有猴子的个数

解题思路：先按照X轴从小到大（X相等排序，y从小到大）；先选择X最大的（极大的y），然后向左边遍历，跟新y的最大值。

#include<iostream>
#include<cstdio>
#include<cstring>
#include <algorithm>
using namespace std;
#define N 50002

struct point{
  int x,y;
  bool operator <(const point &b)const{
    return x!=b.x?(x<b.x):y<b.y;
  }
}p[N];
int main()
{
    int n,i,x,y;
    while(~scanf("%d",&n)&&n)
    {
        for(i=0;i<n;i++)
        {
            scanf("%d%d",&x,&y);
            p[i].x=x;
            p[i].y=y;
        }
        sort(p,p+n);
        int ans=1;
        int mMax = p[n - 1].y; //找出x最大的
        for (i = n- 2; i >= 0; i --)//向左找大于当前的y，不断更新y
        {
            if (mMax < p[i].y)
            {
                mMax = p[i].y;
                ans ++;
            }
        }
        printf("%d\n",ans);
    }
	return 0;
}

G.高精度poj 1131 （8进制小数转换为十进制）

solution one：

//package sunquan;

import java.math.*;
import java.util.*;
public class Main {
	 
	
	 public static void main(String[] args) {
		 BigDecimal ans,base;
		 String str;
		 Scanner in=new Scanner(System.in);
		 
		 while(in.hasNext())
		 {
			 str=in.nextLine();
			 
			 ans=BigDecimal.ZERO;
			 base=BigDecimal.ONE;
			 for(int i=2;i<str.length();i++)
			 {
				 base=base.divide(BigDecimal.valueOf(8));
				 long x= (str.charAt(i)-'0');
				 ans=ans.add(base.multiply(BigDecimal.valueOf(x)));
				 
			 }
			 System.out.println(str+" [8] = "+ans+" [10]");
		 }
	 }

}

solution two：

思路：高精度除法
8进制小数n=0.C1C2C3...Cn ;转化为十进制采用除法；
(1)首先我们先思考一下十进制的小数转十进制
ans=0.(C1+(C2+...)/10)/10
那么： ans=0.(C1+(C2+..)/8)/8
eg： 0.75=0.(7+5/8)/8

#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;
char str[100];
int base[4000];
int main()
{
    int i,j,k,n,t,len;
    while(scanf("%s",str)!=EOF)
    {
        memset(base,0,sizeof(base));
        len=strlen(str);
        for(t=0,i=len-1;i>=2;i--){
            n=str[i]-'0';
            for(k=j=0;j<t||n;j++,k++){
                n=n*10+base[j];//将左边的一位放在前面，然后取头两位做除法
                base[k]=n/8;
                n%=8;
               // cout<<base[k-1];
            }
            t=k;
            //cout<<endl;
        }
        printf("%s [8] = 0.",str);
        for(i=0;i<t;i++)
            printf("%d",base[i]);
        puts(" [10]");
    }
    return 0;
}

H.动态规划 poj 1062

//最短路径——Dijkstra算法
//此题的关键在于等级限制的处理，最好的办法是采用枚举，即假设酋长等级为5，等级限制为2，那么需要枚举等级从3~5,4~6,5~7
//从满足改等级范围的结点组成的子图中用Dijkstra来算出最短路径
//小结，通过枚举的方式可以消除一些图与图之间的限制
#include<iostream>
#include<cmath>
#define INF 200000000
#define MAX 101
using namespace std;
int map[MAX][MAX],lev[MAX],d[MAX],value[MAX];
bool within_lim[MAX],v[MAX];//within_lim为满足等级限制的标记数组
int lev_lim,n;
int dijkstra()//Dijkstra算法
{
	int minimum = INF;
	memset(v,0,sizeof(v));//清除所有点的标号
	for(int i = 1;i <= n;++i)	
		d[i] = (i == 1 ? 0 : INF);//设d[0] = 0,其他d[i] = INF
	for(int i = 1;i <= n;++i)//循环N次
	{
		int x = 0, m = INF;
		for(int y = 1; y <= n;++y)
			if(!v[y] && d[y] <= m && within_lim[y])//在所有未标号且满足等级限制的结点中，选出d值最小的结点x
			{
				x = y;
				m = d[y];
			}
		v[x] = 1;//给结点x标记
		for(int y = 1;y <= n;++y)//对于从x出发的所有边(x,y)，更新d[y] = min{d[y], d[x] + map[x][y])
		{
			if(within_lim[y])//满足等级限制
				d[y] = min(d[y],d[x] + map[x][y]);//更新d[y]值
		}
	}
	for(int i = 1;i <= n;++i)
	{
		d[i] += value[i];//对于每个d[i]值，还需加上进入该结点的花费，再进行比较
		if(d[i] < minimum)	minimum = d[i];
	}
	return minimum;
}
int main()
{
	//freopen("in.txt","r",stdin);
	//freopen("out.txt","w",stdout);
	cin >> lev_lim >> n;
	for(int i = 0;i <= n;++i)
		for(int j = 0;j <= n;++j)
			map[i][j] = (i == j ? 0 : INF);//图的初始化，注意对角线初始化为0，从自己出发到自己的花费为0
	for(int i = 1;i <= n;++i)
	{
		int t;
		cin >> value[i] >> lev[i] >> t;
		for(int j = 1;j <= t;++j)
		{
			int k;
			cin >> k;
			cin >> map[i][k];
		}
	}//建图完毕
	
	int kinglev = lev[1];
	int min_cost = INF,cost;
	for(int i = 0;i <= lev_lim;++i)
	{
		memset(within_lim,0,sizeof(within_lim));//初始化标记数组
		for(int j = 1;j <= n;++j)
			if(lev[j] >= kinglev - lev_lim + i && lev[j] <= kinglev + i)//枚举等级允许范围的结点
				within_lim[j] = 1;
		
		cost = dijkstra();
		if(cost < min_cost)
			min_cost = cost;
	}
	cout << min_cost << endl;
	return 0;
}