P1223 排队接水/1319：【例6.1】排队接水

最新推荐文章于 2024-02-23 16:22:54 发布
最新推荐文章于 2024-02-23 16:22:54 发布
阅读量1.3k 收藏 1
点赞数 1
文章标签： 大数据 java servlet html 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Xiaorui_xuan/article/details/125646057
版权

P1223 排队接水/1319：【例6.1】排队接水

 

# 排队接水

## 题目描述

有 $n$ 个人在一个水龙头前排队接水，假如每个人接水的时间为 $T_i$，请编程找出这 $n$ 个人排队的一种顺序，使得 $n$ 个人的平均等待时间最小。

## 输入格式

第一行为一个整数 $n$。

第二行 $n$ 个整数，第 $i$ 个整数 $T_i$ 表示第 $i$ 个人的等待时间 $T_i$。

## 输出格式

输出文件有两行，第一行为一种平均时间最短的排队顺序；第二行为这种排列方案下的平均等待时间（输出结果精确到小数点后两位）。

## 样例 #1

### 样例输入 #1

```
10 
56 12 1 99 1000 234 33 55 99 812
```

### 样例输出 #1

```
3 2 7 8 1 4 9 6 10 5
291.90
```

## 提示

$n \leq 1000,t_i \leq 10^6$，不保证 $t_i$ 不重复。

当 $t_i$ 重复时，按照输入顺序即可（sort 是可以的）

【俩81分代码】

#include<stdio.h>
#include<iostream>
using namespace std;
const int N=1e3;
inline int fread()
{
	char ch=getchar();
	int n=0,m=1;
	while(ch<'0' or ch>'9')
	{
		if(ch=='-')m=-1;
		ch=getchar();
	}
	while(ch>='0' and ch<='9')n=(n<<3)+(n<<1)+ch-48,ch=getchar();
	return n*m;
}
int n,a[N],t[N];
double cnt,sum;
void sort()
{
	for(int i=1;i<=n;i++)
		for(int j=i+1;j<=n;j++)
			if(t[i]>t[j])swap(t[i],t[j]),swap(a[i],a[j]);
}
signed main()
{
	n=fread();
	for(int i=1;i<=n;i++)t[i]=fread(),a[i]=i;
	sort();
	for(int i=1;i<=n;i++)cnt+=t[i]*(n-(i-1)),sum+=t[i];
	for(int i=1;i<=n;i++)printf("%d ",a[i]);
	printf("\n%.2lf",(cnt-sum)/n);
	return 0;
}

数组开小了。  

给个关注吧 
#include<stdio.h>
#include<iostream>
using namespace std;
#define int long long
const int N=1e3;
inline int fread()
{
	char ch=getchar();
	int n=0,m=1;
	while(ch<'0' or ch>'9')
	{
		if(ch=='-')m=-1;
		ch=getchar();
	}
	while(ch>='0' and ch<='9')n=(n<<3)+(n<<1)+ch-48,ch=getchar();
	return n*m;
}
int n,a[N],t[N];
double cnt,sum;
void sort()
{
	for(int i=1;i<=n;i++)
		for(int j=i+1;j<=n;j++)
			if(t[i]>t[j])swap(t[i],t[j]),swap(a[i],a[j]);
}
signed main()
{
	n=fread();
	for(int i=1;i<=n;i++)t[i]=fread(),a[i]=i;
	sort();
	for(int i=1;i<=n;i++)cnt+=t[i]*(n-(i-1)),sum+=t[i];
	for(int i=1;i<=n;i++)printf("%d ",a[i]);
	printf("\n%.2lf",(cnt-sum)/n);
	return 0;
}

 

给个关注吧

 【AC代码】

#include<stdio.h>
#include<iostream>
using namespace std;
const int N=1e4;
inline int fread()
{
	char ch=getchar();
	int n=0,m=1;
	while(ch<'0' or ch>'9')
	{
		if(ch=='-')m=-1;
		ch=getchar();
	}
	while(ch>='0' and ch<='9')n=(n<<3)+(n<<1)+ch-48,ch=getchar();
	return n*m;
}
int n,a[N],t[N];
double cnt,sum;
void sort()
{
	for(int i=1;i<=n;i++)
		for(int j=i+1;j<=n;j++)
			if(t[i]>t[j])swap(t[i],t[j]),swap(a[i],a[j]);
}
signed main()
{
	n=fread();
	for(int i=1;i<=n;i++)t[i]=fread(),a[i]=i;
	sort();
	for(int i=1;i<=n;i++)cnt+=t[i]*(n-(i-1)),sum+=t[i];
	for(int i=1;i<=n;i++)printf("%d ",a[i]);
	printf("\n%.2lf",(cnt-sum)/n);
	return 0;
}
给个关注吧

 【一堆运行超时代码】

#include<stdio.h>
#include<iostream>
using namespace std;
const int N=1e4;
inline int fread()
{
	char ch=getchar();
	int n=0,m=1;
	while(ch<'0' or ch>'9')
	{
		if(ch=='-')m=-1;
		ch=getchar();
	}
	while(ch>='0' and ch<='9')n=(n<<3)+(n<<1)+ch-48,ch=getchar();
	return n*m;
}
int n,a[N],t[N];
double cnt,sum;
void sort()
{
	for(int i=1;i<=n;i++)
		for(int j=i+1;j<=n;j++)
			if(t[i]>t[j])swap(t[i],t[j]),swap(a[i],a[j]);
}
signed main()
{
	n=fread();
	for(int i=1;i<=n;i++)t[i]=fread(),a[i]=i;
	sort();
	for(int i=1;i<=n;i++)cnt+=t[i]*(n-(i-1)),sum+=t[i];
	for(int i=1;i<=n;i++)printf("%d ",a[i]);
	printf("\n%.2lf",(cnt-sum)/n);
	return 0;
}
给个关注吧

 

#include<stdio.h>
#include<iostream>
using namespace std;
const int N=1e4;
#pragma GCC optimize(2)
#pragma GCC optimize(3)
#pragma GCC optimize("Ofast")
#pragma GCC optimize("inline")
#pragma GCC optimize("-fgcse")
#pragma GCC optimize("-fgcse-lm")
#pragma GCC optimize("-fipa-sra")
#pragma GCC optimize("-ftree-pre")
#pragma GCC optimize("-ftree-vrp")
#pragma GCC optimize("-fpeephole2")
#pragma GCC optimize("-ffast-math")
#pragma GCC optimize("-fsched-spec")
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("-falign-jumps")
#pragma GCC optimize("-falign-loops")
#pragma GCC optimize("-falign-labels")
#pragma GCC optimize("-fdevirtualize")
#pragma GCC optimize("-fcaller-saves")
#pragma GCC optimize("-fcrossjumping")
#pragma GCC optimize("-fthread-jumps")
#pragma GCC optimize("-funroll-loops")
#pragma GCC optimize("-fwhole-program")
#pragma GCC optimize("-freorder-blocks")
#pragma GCC optimize("-fschedule-insns")
#pragma GCC optimize("inline-functions")
#pragma GCC optimize("-ftree-tail-merge")
#pragma GCC optimize("-fschedule-insns2")
#pragma GCC optimize("-fstrict-aliasing")
#pragma GCC optimize("-fstrict-overflow")
#pragma GCC optimize("-falign-functions")
#pragma GCC optimize("-fcse-skip-blocks")
#pragma GCC optimize("-fcse-follow-jumps")
#pragma GCC optimize("-fsched-interblock")
#pragma GCC optimize("-fpartial-inlining")
#pragma GCC optimize("no-stack-protector")
#pragma GCC optimize("-freorder-functions")
#pragma GCC optimize("-findirect-inlining")
#pragma GCC optimize("-fhoist-adjacent-loads")
#pragma GCC optimize("-frerun-cse-after-loop")
#pragma GCC optimize("inline-small-functions")
#pragma GCC optimize("-finline-small-functions")
#pragma GCC optimize("-ftree-switch-conversion")
#pragma GCC optimize("-foptimize-sibling-calls")
#pragma GCC optimize("-fexpensive-optimizations")
#pragma GCC optimize("-funsafe-loop-optimizations")
#pragma GCC optimize("inline-functions-called-once")
#pragma GCC optimize("-fdelete-null-pointer-checks")
inline int fread()
{
	char ch=getchar();
	int n=0,m=1;
	while(ch<'0' or ch>'9')
	{
		if(ch=='-')m=-1;
		ch=getchar();
	}
	while(ch>='0' and ch<='9')n=(n<<3)+(n<<1)+ch-48,ch=getchar();
	return n*m;
}
int n,a[N],t[N];
double cnt,sum;
void sort()
{
	for(int i=1;i<=n;i++)
		for(int j=i+1;j<=n;j++)
			if(t[i]>t[j])swap(t[i],t[j]),swap(a[i],a[j]);
}
signed main()
{
	n=fread();
	for(int i=1;i<=n;i++)t[i]=fread(),a[i]=i;
	sort();
	for(int i=1;i<=n;i++)cnt+=t[i]*(n-(i-1)),sum+=t[i];
	for(int i=1;i<=n;i++)printf("%d ",a[i]);
	printf("\n%.2lf",(cnt-sum)/n);
	return 0;
}
给个关注吧

 

#include<stdio.h>
#include<iostream>
using namespace std;
const int N=1e4;
#pragma GCC optimize(2)
#pragma GCC optimize(3)
#pragma GCC optimize("Ofast")
#pragma GCC optimize("inline")
#pragma GCC optimize("-fgcse")
#pragma GCC optimize("-fgcse-lm")
#pragma GCC optimize("-fipa-sra")
#pragma GCC optimize("-ftree-pre")
#pragma GCC optimize("-ftree-vrp")
#pragma GCC optimize("-fpeephole2")
#pragma GCC optimize("-ffast-math")
#pragma GCC optimize("-fsched-spec")
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("-falign-jumps")
#pragma GCC optimize("-falign-loops")
#pragma GCC optimize("-falign-labels")
#pragma GCC optimize("-fdevirtualize")
#pragma GCC optimize("-fcaller-saves")
#pragma GCC optimize("-fcrossjumping")
#pragma GCC optimize("-fthread-jumps")
#pragma GCC optimize("-funroll-loops")
#pragma GCC optimize("-fwhole-program")
#pragma GCC optimize("-freorder-blocks")
#pragma GCC optimize("-fschedule-insns")
#pragma GCC optimize("inline-functions")
#pragma GCC optimize("-ftree-tail-merge")
#pragma GCC optimize("-fschedule-insns2")
#pragma GCC optimize("-fstrict-aliasing")
#pragma GCC optimize("-fstrict-overflow")
#pragma GCC optimize("-falign-functions")
#pragma GCC optimize("-fcse-skip-blocks")
#pragma GCC optimize("-fcse-follow-jumps")
#pragma GCC optimize("-fsched-interblock")
#pragma GCC optimize("-fpartial-inlining")
#pragma GCC optimize("no-stack-protector")
#pragma GCC optimize("-freorder-functions")
#pragma GCC optimize("-findirect-inlining")
#pragma GCC optimize("-fhoist-adjacent-loads")
#pragma GCC optimize("-frerun-cse-after-loop")
#pragma GCC optimize("inline-small-functions")
#pragma GCC optimize("-finline-small-functions")
#pragma GCC optimize("-ftree-switch-conversion")
#pragma GCC optimize("-foptimize-sibling-calls")
#pragma GCC optimize("-fexpensive-optimizations")
#pragma GCC optimize("-funsafe-loop-optimizations")
#pragma GCC optimize("inline-functions-called-once")
#pragma GCC optimize("-fdelete-null-pointer-checks")
inline int fread()
{
	char ch=getchar();
	int n=0,m=1;
	while(ch<'0' or ch>'9')
	{
		if(ch=='-')m=-1;
		ch=getchar();
	}
	while(ch>='0' and ch<='9')n=(n<<3)+(n<<1)+ch-48,ch=getchar();
	return n*m;
}
int n,a[N],t[N];
double cnt,sum;
inline void sort()
{
	for(register int i=1;i<=n;i++)
		for(register int j=i+1;j<=n;j++)
			if(t[i]>t[j])swap(t[i],t[j]),swap(a[i],a[j]);
}
signed main()
{
	n=fread();
	for(register int i=1;i<=n;i++)t[i]=fread(),a[i]=i;
	sort();
	for(register int i=1;i<=n;i++)cnt+=t[i]*(n-(i-1)),sum+=t[i];
	for(register int i=1;i<=n;i++)printf("%d ",a[i]);
	printf("\n%.2lf",(cnt-sum)/n);
	return 0;
}
给个关注吧

 

#include<stdio.h>
#include<iostream>
using namespace std;
const int N=1e4;
#pragma GCC optimize(2)
#pragma GCC optimize(3)
#pragma GCC optimize("Ofast")
#pragma GCC optimize("inline")
#pragma GCC optimize("-fgcse")
#pragma GCC optimize("-fgcse-lm")
#pragma GCC optimize("-fipa-sra")
#pragma GCC optimize("-ftree-pre")
#pragma GCC optimize("-ftree-vrp")
#pragma GCC optimize("-fpeephole2")
#pragma GCC optimize("-ffast-math")
#pragma GCC optimize("-fsched-spec")
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("-falign-jumps")
#pragma GCC optimize("-falign-loops")
#pragma GCC optimize("-falign-labels")
#pragma GCC optimize("-fdevirtualize")
#pragma GCC optimize("-fcaller-saves")
#pragma GCC optimize("-fcrossjumping")
#pragma GCC optimize("-fthread-jumps")
#pragma GCC optimize("-funroll-loops")
#pragma GCC optimize("-fwhole-program")
#pragma GCC optimize("-freorder-blocks")
#pragma GCC optimize("-fschedule-insns")
#pragma GCC optimize("inline-functions")
#pragma GCC optimize("-ftree-tail-merge")
#pragma GCC optimize("-fschedule-insns2")
#pragma GCC optimize("-fstrict-aliasing")
#pragma GCC optimize("-fstrict-overflow")
#pragma GCC optimize("-falign-functions")
#pragma GCC optimize("-fcse-skip-blocks")
#pragma GCC optimize("-fcse-follow-jumps")
#pragma GCC optimize("-fsched-interblock")
#pragma GCC optimize("-fpartial-inlining")
#pragma GCC optimize("no-stack-protector")
#pragma GCC optimize("-freorder-functions")
#pragma GCC optimize("-findirect-inlining")
#pragma GCC optimize("-fhoist-adjacent-loads")
#pragma GCC optimize("-frerun-cse-after-loop")
#pragma GCC optimize("inline-small-functions")
#pragma GCC optimize("-finline-small-functions")
#pragma GCC optimize("-ftree-switch-conversion")
#pragma GCC optimize("-foptimize-sibling-calls")
#pragma GCC optimize("-fexpensive-optimizations")
#pragma GCC optimize("-funsafe-loop-optimizations")
#pragma GCC optimize("inline-functions-called-once")
#pragma GCC optimize("-fdelete-null-pointer-checks")
inline int fread()
{
	char ch=getchar();
	int n=0,m=1;
	while(ch<'0' or ch>'9')
	{
		if(ch=='-')m=-1;
		ch=getchar();
	}
	while(ch>='0' and ch<='9')n=(n<<3)+(n<<1)+ch-48,ch=getchar();
	return n*m;
}
int n,a[N],t[N];
double cnt,sum;
inline void sort()
{
	for(register int i=1;i<=n;i++)
		for(register int j=n;j>0;j--)
			if(t[j]<t[j-1])swap(t[j],t[j-1]),swap(a[j],a[j-1]);
}
signed main()
{
	n=fread();
	for(register int i=1;i<=n;i++)t[i]=fread(),a[i]=i;
	sort();
	for(register int i=1;i<=n;i++)cnt+=t[i]*(n-(i-1)),sum+=t[i];
	for(register int i=1;i<=n;i++)printf("%d ",a[i]);
	printf("\n%.2lf",(cnt-sum)/n);
	return 0;
}
给个关注吧

 

#include<stdio.h>
#include<iostream>
using namespace std;
const int N=1e4;
#pragma GCC optimize(2)
#pragma GCC optimize(3)
#pragma GCC optimize("Ofast")
#pragma GCC optimize("inline")
#pragma GCC optimize("-fgcse")
#pragma GCC optimize("-fgcse-lm")
#pragma GCC optimize("-fipa-sra")
#pragma GCC optimize("-ftree-pre")
#pragma GCC optimize("-ftree-vrp")
#pragma GCC optimize("-fpeephole2")
#pragma GCC optimize("-ffast-math")
#pragma GCC optimize("-fsched-spec")
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("-falign-jumps")
#pragma GCC optimize("-falign-loops")
#pragma GCC optimize("-falign-labels")
#pragma GCC optimize("-fdevirtualize")
#pragma GCC optimize("-fcaller-saves")
#pragma GCC optimize("-fcrossjumping")
#pragma GCC optimize("-fthread-jumps")
#pragma GCC optimize("-funroll-loops")
#pragma GCC optimize("-fwhole-program")
#pragma GCC optimize("-freorder-blocks")
#pragma GCC optimize("-fschedule-insns")
#pragma GCC optimize("inline-functions")
#pragma GCC optimize("-ftree-tail-merge")
#pragma GCC optimize("-fschedule-insns2")
#pragma GCC optimize("-fstrict-aliasing")
#pragma GCC optimize("-fstrict-overflow")
#pragma GCC optimize("-falign-functions")
#pragma GCC optimize("-fcse-skip-blocks")
#pragma GCC optimize("-fcse-follow-jumps")
#pragma GCC optimize("-fsched-interblock")
#pragma GCC optimize("-fpartial-inlining")
#pragma GCC optimize("no-stack-protector")
#pragma GCC optimize("-freorder-functions")
#pragma GCC optimize("-findirect-inlining")
#pragma GCC optimize("-fhoist-adjacent-loads")
#pragma GCC optimize("-frerun-cse-after-loop")
#pragma GCC optimize("inline-small-functions")
#pragma GCC optimize("-finline-small-functions")
#pragma GCC optimize("-ftree-switch-conversion")
#pragma GCC optimize("-foptimize-sibling-calls")
#pragma GCC optimize("-fexpensive-optimizations")
#pragma GCC optimize("-funsafe-loop-optimizations")
#pragma GCC optimize("inline-functions-called-once")
#pragma GCC optimize("-fdelete-null-pointer-checks")
inline int fread()
{
	char ch=getchar();
	int n=0,m=1;
	while(ch<'0' or ch>'9')
	{
		if(ch=='-')m=-1;
		ch=getchar();
	}
	while(ch>='0' and ch<='9')n=(n<<3)+(n<<1)+ch-48,ch=getchar();
	return n*m;
}
int n,a[N],t[N];
double cnt,sum;
inline void sort()
{
	for(register int i=1;i<=n;i++)
		for(register int j=i+1;j<=n;j++)
			if(t[i]>t[j])swap(t[i],t[j]),swap(a[i],a[j]);
}
signed main()
{
	n=fread();
	for(register int i=1;i<=n;i++)t[i]=fread(),a[i]=i;
	sort();
	for(register int i=1;i<=n;i++)
	{
		cnt+=t[i]*(n-i+1),sum+=t[i];
		printf("%d ",a[i]);
	}
	printf("\n%.2lf",(cnt-sum)/n);
	return 0;
}
给个关注吧

 

#include<stdio.h>
#include<iostream>
using namespace std;
const int N=1e4;
#define ing long long
#pragma GCC optimize(2)
#pragma GCC optimize(3)
#pragma GCC optimize("Ofast")
#pragma GCC optimize("inline")
#pragma GCC optimize("-fgcse")
#pragma GCC optimize("-fgcse-lm")
#pragma GCC optimize("-fipa-sra")
#pragma GCC optimize("-ftree-pre")
#pragma GCC optimize("-ftree-vrp")
#pragma GCC optimize("-fpeephole2")
#pragma GCC optimize("-ffast-math")
#pragma GCC optimize("-fsched-spec")
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("-falign-jumps")
#pragma GCC optimize("-falign-loops")
#pragma GCC optimize("-falign-labels")
#pragma GCC optimize("-fdevirtualize")
#pragma GCC optimize("-fcaller-saves")
#pragma GCC optimize("-fcrossjumping")
#pragma GCC optimize("-fthread-jumps")
#pragma GCC optimize("-funroll-loops")
#pragma GCC optimize("-fwhole-program")
#pragma GCC optimize("-freorder-blocks")
#pragma GCC optimize("-fschedule-insns")
#pragma GCC optimize("inline-functions")
#pragma GCC optimize("-ftree-tail-merge")
#pragma GCC optimize("-fschedule-insns2")
#pragma GCC optimize("-fstrict-aliasing")
#pragma GCC optimize("-fstrict-overflow")
#pragma GCC optimize("-falign-functions")
#pragma GCC optimize("-fcse-skip-blocks")
#pragma GCC optimize("-fcse-follow-jumps")
#pragma GCC optimize("-fsched-interblock")
#pragma GCC optimize("-fpartial-inlining")
#pragma GCC optimize("no-stack-protector")
#pragma GCC optimize("-freorder-functions")
#pragma GCC optimize("-findirect-inlining")
#pragma GCC optimize("-fhoist-adjacent-loads")
#pragma GCC optimize("-frerun-cse-after-loop")
#pragma GCC optimize("inline-small-functions")
#pragma GCC optimize("-finline-small-functions")
#pragma GCC optimize("-ftree-switch-conversion")
#pragma GCC optimize("-foptimize-sibling-calls")
#pragma GCC optimize("-fexpensive-optimizations")
#pragma GCC optimize("-funsafe-loop-optimizations")
#pragma GCC optimize("inline-functions-called-once")
#pragma GCC optimize("-fdelete-null-pointer-checks")
inline int fread()
{
	char ch=getchar();
	int n=0,m=1;
	while(ch<'0' or ch>'9')
	{
		if(ch=='-')m=-1;
		ch=getchar();
	}
	while(ch>='0' and ch<='9')n=(n<<3)+(n<<1)+ch-48,ch=getchar();
	return n*m;
}
int n,a[N],t[N];
double cnt,sum;
inline void sort()
{
	for(register int i=1;i<=n;i++)
		for(register int j=i+1;j<=n;j++)
			if(t[i]>t[j])swap(t[i],t[j]),swap(a[i],a[j]);
}
signed main()
{
	n=fread();
	for(register int i=1;i<=n;i++)t[i]=fread(),a[i]=i;
	sort();
	for(register int i=1;i<=n;i++)cnt+=t[i]*(n-i+1),sum+=t[i];
	for(register int i=1;i<=n;i++)printf("%d ",a[i]);
	printf("\n%.2lf",(cnt-sum)/n);
	return 0;
}
给个关注吧

 

#include<stdio.h>
#include<iostream>
using namespace std;
const int N=1e4;
#pragma GCC optimize(2)
#pragma GCC optimize(3)
#pragma GCC optimize("Ofast")
#pragma GCC optimize("inline")
#pragma GCC optimize("-fgcse")
#pragma GCC optimize("-fgcse-lm")
#pragma GCC optimize("-fipa-sra")
#pragma GCC optimize("-ftree-pre")
#pragma GCC optimize("-ftree-vrp")
#pragma GCC optimize("-fpeephole2")
#pragma GCC optimize("-ffast-math")
#pragma GCC optimize("-fsched-spec")
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("-falign-jumps")
#pragma GCC optimize("-falign-loops")
#pragma GCC optimize("-falign-labels")
#pragma GCC optimize("-fdevirtualize")
#pragma GCC optimize("-fcaller-saves")
#pragma GCC optimize("-fcrossjumping")
#pragma GCC optimize("-fthread-jumps")
#pragma GCC optimize("-funroll-loops")
#pragma GCC optimize("-fwhole-program")
#pragma GCC optimize("-freorder-blocks")
#pragma GCC optimize("-fschedule-insns")
#pragma GCC optimize("inline-functions")
#pragma GCC optimize("-ftree-tail-merge")
#pragma GCC optimize("-fschedule-insns2")
#pragma GCC optimize("-fstrict-aliasing")
#pragma GCC optimize("-fstrict-overflow")
#pragma GCC optimize("-falign-functions")
#pragma GCC optimize("-fcse-skip-blocks")
#pragma GCC optimize("-fcse-follow-jumps")
#pragma GCC optimize("-fsched-interblock")
#pragma GCC optimize("-fpartial-inlining")
#pragma GCC optimize("no-stack-protector")
#pragma GCC optimize("-freorder-functions")
#pragma GCC optimize("-findirect-inlining")
#pragma GCC optimize("-fhoist-adjacent-loads")
#pragma GCC optimize("-frerun-cse-after-loop")
#pragma GCC optimize("inline-small-functions")
#pragma GCC optimize("-finline-small-functions")
#pragma GCC optimize("-ftree-switch-conversion")
#pragma GCC optimize("-foptimize-sibling-calls")
#pragma GCC optimize("-fexpensive-optimizations")
#pragma GCC optimize("-funsafe-loop-optimizations")
#pragma GCC optimize("inline-functions-called-once")
#pragma GCC optimize("-fdelete-null-pointer-checks")
inline int fread()
{
	char ch=getchar();
	int n=0,m=1;
	while(ch<'0' or ch>'9')
	{
		if(ch=='-')m=-1;
		ch=getchar();
	}
	while(ch>='0' and ch<='9')n=(n<<3)+(n<<1)+ch-48,ch=getchar();
	return n*m;
}
int n,a[N],t[N];
double cnt,sum;
inline void sort()
{
	for(register int i=1;i<=n;i++)
		for(register int j=i+1;j<=n;j++)
			if(t[i]>t[j])swap(t[i],t[j]),swap(a[i],a[j]);
}
signed main()
{
	std::ios::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);
	n=fread();
	for(register int i=1;i<=n;i++)t[i]=fread(),a[i]=i;
	sort();
	for(register int i=1;i<=n;i++)cnt+=t[i]*(n-i+1),sum+=t[i];
	for(register int i=1;i<=n;i++)printf("%d ",a[i]);
	printf("\n%.2lf",(cnt-sum)/n);
	return 0;
}
给个关注吧

 

#include<algorithm> 
#include<stdio.h>
#include<iostream>
using namespace std;
#define int long long
const int N=1e4;
inline int fread()
{
	char ch=getchar();
	int n=0,m=1;
	while(ch<'0' or ch>'9')
	{
		if(ch=='-')m=-1;
		ch=getchar();
	}
	while(ch>='0' and ch<='9')n=(n<<3)+(n<<1)+ch-48,ch=getchar();
	return n*m;
}
int n,sum,m;
double ans;
struct node
{
	int x,y;
}t[N];
bool cmp(node n,node m)
{
	return n.y<m.y;
}
signed main()
{
	n=fread(),m=n-1;
	for(int i=1;i<=n;i++)t[i].y=fread(),t[i].x=i;
	sort(t+1,t+1+n,cmp);
	for(int i=1;i<=n;i++)printf("%lld ",t[i].x);
	for(int i=1;i<n;i++)sum+=t[i].y*m,m--;
	ans=sum*1.0/n;
	printf("\n%.2lf",ans);
	return 0;
}
给个关注吧

【AC代码】

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
struct water
{
	int time,id;
}a[1010];
bool cmp(struct water a,struct water b) {return a.time<b.time;}
int main()
{
	int n;
	double alltime=0;
	cin>>n;
	for(int i=1;i<=n;i++) 
	{
		cin>>a[i].time;
		a[i].id=i;
	}
	sort(a+1,a+1+n,cmp);
	for(int i=1;i<=n;i++)
	{
		cout<<a[i].id<<" ";
		alltime=alltime+a[i-1].time*(n-i+1);
	}
	printf("\n%.2f",alltime/n);
	return 0;
}

 抄的。

给个关注吧

 【听取T声亿片】

#include<algorithm> 
#include<stdio.h>
#include<iostream>
using namespace std;
const int N=1e4;
inline int fread()
{
	char ch=getchar();
	int n=0,m=1;
	while(ch<'0' or ch>'9')
	{
		if(ch=='-')m=-1;
		ch=getchar();
	}
	while(ch>='0' and ch<='9')n=(n<<3)+(n<<1)+ch-48,ch=getchar();
	return n*m;
}
int n;
double ans;
struct node
{
	int x,y;
}t[N];
bool cmp(node n,node m)
{
	return n.y<m.y;
}
signed main()
{
	n=fread();
	for(int i=1;i<=n;i++)t[i].y=fread(),t[i].x=i;
	sort(t+1,t+1+n,cmp);
	for(int i=1;i<=n;i++)
	{
		printf("%d ",t[i].x);
		ans+=t[i-1].y*(n-i+1);
	}
	printf("\n%.2lf",ans/n);
	return 0;
}

妈的这题有毒老子不做了。 

给个关注吧

 

 

 

暴揍键盘的程序猿
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
算法-排队接水（洛谷-P1223）（包含源程序）.rar
09-16
算法-排队接水（洛谷-P1223）（包含源程序）.rar
排队接水（贪心）
一身清贫怎敢入繁华
06-03 5387
【题目描述】 有nn个人在一个水龙头前排队接水，假如每个人接水的时间为TiTi，请编程找出这nn个人排队的一种顺序，使得nn个人的平均等待时间最小。 【输入】 共两行，第一行为n(1≤n≤1000)n(1≤n≤1000)；第二行分别表示第11个人到第nn个人每人的接水时间T1，T2，…，TnT1，T2，…，Tn，每个数据之间有11个空格。 【输出】 有两行，第一行为一种排队顺序，即11到...
1319：【例6.1】排队接水
qq_55555458的博客
03-17 1018
1319：【例6.1】排队接水（贪心）
一本通-1319：【例6.1】排队接水
最新发布
m0_61990249的博客
02-23 325
排队接水
排队接水(water)----贪心算法
qq_62899367的博客
01-11 2163
题目部分 Description 有n(n<1000)个人在一个水龙头前排队接水，假如每个人接水的时间为Ti，请编程找出这n个人排队的一种顺序，使得n个人的平均等待时间最小。 Input 输入文件共两行，第一行为n；第二行分别表示第1个人到第nn个人每人的接水时间T1,T2,…,Tn，每个数据之间有1个空格。 Output 输出文件有两行，第一行为一种排队顺序，即1到n的一种排列；第二行为这种排列方案下的平均等待时间(输出结果精确到小数点后两位)。 样例输入 10 56 12 1 .
信息学奥赛一本通 1319：排队接水（evd)
everwide的博客
10-18 1194
【题目描述】 有n个人在一个水龙头前排队接水，假如每个人接水的时间为Ti，请编程找出这n个人排队的一种顺序，使得n个人的平均等待时间最小。 【输入】 共两行，第一行为n(1≤n≤1000)；第二行分别表示第1个人到第n个人每人的接水时间T1，T2，…，Tn，每个数据之间有1个空格。 【输出】 有两行，第一行为一种排队顺序，即1到n的一种排列；第二行为这种排列方案下的平均等待时间(输出结果精确到小数点后两位)。 【输入样例】 10 56 12 1 99 1000 234 33 55 99 812
信息学奥赛一本通 1319：【例6.1】排队接水 | 洛谷 P1223 排队接水
君义NOIP的博客
03-23 4663
【题目链接】 ybt 1319：【例6.1】排队接水 洛谷 P1223 排队接水 【题目考点】 1. 贪心 2. 贪心选择性质的证明 要想证明贪心选择可以得到最优解，只需要证明最优解包含每一次的贪心选择。 使用数学归纳法： 证明最优解包含第一次的贪心选择 假设存在最优解包含前k次的贪心选择，证明该最优解包含第k+1次的贪心选择 【解题思路】 1. 证明贪心选择性质 贪心选择：每次选择接水时间最短的人去接水 贪心选择性质的证明： 设n个人的编号为1,2,3,…,n 证明：存在最优解，第一个接水的人是通过
问题 A: 【例6.1】排队接水
云深不知处小课堂
03-25 2712
题目描述有nn 个人在一个水龙头前排队接水，假如每个人接水的时间为TiTi ，请编程找出这nn 个人排队的一种顺序，使得nn 个人的平均等待时间最小。输入共两行，第一行为n(1≤n≤1000)n(1≤n≤1000) ；第二行分别表示第11 个人到第nn 个人每人的接水时间T1，T2，…，TnT1，T2，…，Tn ，每个数据之间有11 个空格。输出有两行，第一行为一种排队顺序，即11 到nn 的一种...
一本通 2.6.1 贪心算法
xuqw11111的专栏
03-07 916
一本通 贪心算法 题目解析
信奥一本通1319
ZQK11的博客
05-03 197
本题选自信息学奥赛一本通 网址:http://ybt.ssoier.cn:8088/
系统补丁：Windows6.1-KB2661332-x64.msu
05-10
远程桌面连接蓝屏死机补丁，2008 r2服务器补丁，KB2661332。 官方解释：https://support.microsoft.com/zh-cn/help/2661332
6.1并行显示接口电路.ppt
11-21
6.1并行显示接口电路.ppt
火车头discuz6.1 完美采集的php接口文件
10-29
火车头官方提供的discuz6.1的php接口比较粗糙，基本不能满足需要，本人在采集的工作中使用的采集接口文件如下
calendar-liferay-6-1:Liferay 6.1中的日历插件
05-20
这个插件（或Portlet项目）只不过为Liferay Portal 6.1提出了响应时间表（移动或桌面）。 关于前端已从Code Canyon的产品代码开始开发。 然后修改了CSS和JavaScript / jQuery。 对于后端，我使用了API Liferay ...
软件系统设计与体系结构：Ch6.1 Software Architectures Design.ppt
06-27
软件系统设计与体系结构：Ch6.1 Software Architectures Design.ppt
排队接水（C++，贪心）
m0_74036684的博客
12-02 379
一道很典型的贪心题目，使耗时越短的人排在越前面，之后证明贪心正确即可
【洛谷 P1223】排队接水（贪心算法+结构体排序）
HEX9CF的技术博客
03-21 162
有n个人在一个水龙头前排队接水，假如每个人接水的时间为Ti​，请编程找出这n个人排队的一种顺序，使得n个人的平均等待时间最小。
【例6.1】排队接水 贪心算法
m0_46183615的博客
01-09 635
时间限制: 1000 ms 内存限制: 65536 KB【题目描述】有n个人在一个水龙头前排队接水，假如每个人接水的时间为Ti，请编程找出这n个人排队的一种顺序，使得n个人的平均等待时间最小。共两行，第一行为n(1≤n≤1000)；第二行分别表示第1个人到第n个人每人的接水时间T1，T2，…，Tn，每个数据之间有1个空格。有两行，第一行为一种排队顺序，即1到n的一种排列；第二行为这种排列方案下的平均等待时间(输出结果精确到小数点后两位)。10291.90。
1319:【例6.1】排队接水
08-24
1319:【例6.1】排队接水是一道题目，考点包括贪心和贪心选择性质的证明。这道题目是关于排队接水的问题，其中贪心选择的策略是每次选择接水时间最短的人去接水。贪心选择性质的证明则是要证明存在最优解，第一个接水的人是通过贪心选择得到的。<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* *3* [信息学奥赛一本通 1319：【例6.1】排队接水 | 洛谷 P1223 排队接水](https://blog.csdn.net/lq1990717/article/details/123697433)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_1"}}] [.reference_item style="max-width: 50%"] - *2* [Java典型模块与项目实战大全_周华清](https://download.csdn.net/download/lyy8023/6843883)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_1"}}] [.reference_item style="max-width: 50%"] [ .reference_list ]

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值