Lost Cows(暴力解法+线段树优化）

最新推荐文章于 2024-08-02 20:34:24 发布
最新推荐文章于 2024-08-02 20:34:24 发布
阅读量402 收藏
点赞数
分类专栏： 线段树 数据结构 算法入门 文章标签： css html5 html
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_57006708/article/details/120402291
版权

Lost Cows

Description :


N (2 <= N <= 8,000) cows have unique brands in the range 1..N. In a spectacular display of poor judgment, they visited the neighborhood ‘watering hole’ and drank a few too many beers before dinner. When it was time to line up for their evening meal, they did not line up in the required ascending numerical order of their brands. 
Regrettably, FJ does not have a way to sort them. Furthermore, he’s not very good at observing problems. Instead of writing down each cow’s brand, he determined a rather silly statistic: For each cow in line, he knows the number of cows that precede that cow in line that do, in fact, have smaller brands than that cow. 
Given this data, tell FJ the exact ordering of the cows.

Input 


* Line 1: A single integer, N 
* Lines 2..N: These N-1 lines describe the number of cows that precede a given cow in line and have brands smaller than that cow. Of course, no cows precede the first cow in line, so she is not listed. Line 2 of the input describes the number of preceding cows whose brands are smaller than the cow in slot #2; line 3 describes the number of preceding cows whose brands are smaller than the cow in slot #3; and so on. 
* 


Output 


* Lines 1..N: Each of the N lines of output tells the brand of a cow in line. Line #1 of the output tells the brand of the first cow in line; line 2 tells the brand of the second cow; and so on. 
* 


Sample Input 


5 
1 
2 
1 
0

Sample Output :


2 
4 
5 
3 
1

题意：N头奶牛排队，它们的身高为1~n，知道每头牛前面有多少头比自己矮，求每头牛的身高。


暴力解法：

/*
*@Author:   GuoJinlong
*@Language: C++
*/
//#include <bits/stdc++.h>
#include<iostream>
#include<cstdio>
#include<string>
#include<queue>
#include<stack>
#include<map>
#include<vector>
#include<list>
#include<set>
#include<iomanip>
#include<cstring>
#include<cctype>
#include<cmath>
#include<cstdlib>
#include<ctime>
#include<cassert>
#include<sstream>
#include<algorithm>
using namespace std;
const int mod=1e9+7;
typedef long long  ll;
#define ls (p<<1)
#define rs (p<<1|1)
#define mid (l+r)/2
#define over(i,s,t) for(register long long i=s;i<=t;++i)
#define lver(i,t,s) for(register long long i=t;i>=s;--i)
const int MAXN = 305;
const int INF = 0x3f3f3f3f;
const int N=5e4+7;
const int maxn=1e5+5;
const double EPS=1e-10;
const double Pi=3.1415926535897;
//inline double max(double a,double b){
//    return a>b?a:b;
//}
//inline double min(double a,double b){
//    return a<b?a:b;
//}
 
int xd[8] = {0, 1, 0, -1, 1, 1, -1, -1};
int yd[8] = {1, 0, -1, 0, -1, 1, -1, 1};
 
//void Fire(){
//    queue<node> p;
//    p.push({fx,fy,0});
//    memset(fire, -1, sizeof(fire));
//    fire[fx][fy]=0;
//    while(!p.empty()){
//        node temp=p.front();
//        p.pop();
//        for(int i=0;i<8;i++){
//            int x=temp.x+xd[i];
//            int y=temp.y+yd[i];
//            if(x<0||x>=n||y<0||y>=m||fire[x][y]!=-1){
//                continue;
//            }
//            fire[x][y]=temp.val+1;
//            p.push({x,y,temp.val+1});
//        }
//    }
//}
//int bfs(){
//    queue<node> p;
//    memset(vis, 0, sizeof(vis));
//    p.push({sx,sy,0});
//    while (!p.empty()) {
//        node temp=p.front();
//        vis[temp.x][temp.y]=1;
//        p.pop();
//        for(int i=0;i<4;i++){
//            int x=temp.x+xd[i];
//            int y=temp.y+yd[i];
//            if(x<0||x>=n||y<0||y>=m)  continue;
//            if(x==ex&&y==ey&&temp.val+1<=fire[x][y]) return temp.val+1;
//            if(vis[x][y]||temp.val+1>=fire[x][y]||a[x][y]=='#') continue;
//            p.push({x,y,temp.val+1});
//        }
//    }
//    return -1;
//}

//一维哈希
//int n;
//string s;
//int bas=131;
//typedef unsigned long long ull;
//const ull mod1=100001651;
//ull a[100010];
//ull Hash(string s){
//    ll ans=0;
//    for(int i=0;i<s.size();i++){
//        ans*=bas;
//        ans+=int(s[i]);
//        ans%=mod1;
//    }
//    return ans;
//}

//二维哈希
//using lom=unsigned long long ;
//const lom bas1=131,bas2=233;
//const int M=505;
//int n,m;
//char a[M][M];
//lom _hash[M][M];
//lom p1[M],p2[M];
//
//
//void init(){
//    p1[0]=1;
//    p2[0]=1;
//    for(int i=1;i<=505;i++){
//        p1[i]=p1[i-1]*bas1;
//        p2[i]=p2[i-1]*bas2;
//
//    }
//}
//void Hash(){
//    _hash[0][0]=_hash[0][1]=_hash[1][0]=0;
//    for(int i=1;i<=n;i++){    //前缀和
//        for(int j=1;j<=m;j++){
//            _hash[i][j]=_hash[i][j-1]*bas1+a[i][j]-'a';
//        }
//    }
//    for(int i=1;i<=n;i++){   //二维前缀和
//        for(int j=1;j<=m;j++){
//            _hash[i][j]+=_hash[i-1][j]*bas2;
//        }
//    }
//
//}

int n;

int pre[10010];
int vis[100010];
int num[100010];
int main(){
    cin>>n;
    for(int i=0;i<n;i++){
        cin>>pre[i];
    }
    int k=0;
    for(int i=n-1;i>=0;i--){
        k=0;
        for(int j=1;j<=n;j++){
            if(!vis[j]) k++;
            if(k==pre[i]+1){
//                cout<<j<<" ";
                num[i]=j;
                vis[j]=1;
                break;
            }
        }
    }
    for(int i=0;i<n;i++ )
        cout<<num[i]<<" ";
}

线段树解法

/*
*@Author:   GuoJinlong
*@Language: C++
*/
//#include <bits/stdc++.h>
#include<iostream>
#include<cstdio>
#include<string>
#include<queue>
#include<stack>
#include<map>
#include<vector>
#include<list>
#include<set>
#include<iomanip>
#include<cstring>
#include<cctype>
#include<cmath>
#include<cstdlib>
#include<ctime>
#include<cassert>
#include<sstream>
#include<algorithm>
using namespace std;
const int mod=1e9+7;
typedef long long  ll;
#define ls (p<<1)
#define rs (p<<1|1)
#define mid (l+r)/2
#define over(i,s,t) for(register long long i=s;i<=t;++i)
#define lver(i,t,s) for(register long long i=t;i>=s;--i)
const int MAXN = 305;
const int INF = 0x3f3f3f3f;
const int N=5e4+7;
const int maxn=1e5+5;
const double EPS=1e-10;
const double Pi=3.1415926535897;
//inline double max(double a,double b){
//    return a>b?a:b;
//}
//inline double min(double a,double b){
//    return a<b?a:b;
//}
 
int xd[8] = {0, 1, 0, -1, 1, 1, -1, -1};
int yd[8] = {1, 0, -1, 0, -1, 1, -1, 1};
 
//void Fire(){
//    queue<node> p;
//    p.push({fx,fy,0});
//    memset(fire, -1, sizeof(fire));
//    fire[fx][fy]=0;
//    while(!p.empty()){
//        node temp=p.front();
//        p.pop();
//        for(int i=0;i<8;i++){
//            int x=temp.x+xd[i];
//            int y=temp.y+yd[i];
//            if(x<0||x>=n||y<0||y>=m||fire[x][y]!=-1){
//                continue;
//            }
//            fire[x][y]=temp.val+1;
//            p.push({x,y,temp.val+1});
//        }
//    }
//}
//int bfs(){
//    queue<node> p;
//    memset(vis, 0, sizeof(vis));
//    p.push({sx,sy,0});
//    while (!p.empty()) {
//        node temp=p.front();
//        vis[temp.x][temp.y]=1;
//        p.pop();
//        for(int i=0;i<4;i++){
//            int x=temp.x+xd[i];
//            int y=temp.y+yd[i];
//            if(x<0||x>=n||y<0||y>=m)  continue;
//            if(x==ex&&y==ey&&temp.val+1<=fire[x][y]) return temp.val+1;
//            if(vis[x][y]||temp.val+1>=fire[x][y]||a[x][y]=='#') continue;
//            p.push({x,y,temp.val+1});
//        }
//    }
//    return -1;
//}

//一维哈希
//int n;
//string s;
//int bas=131;
//typedef unsigned long long ull;
//const ull mod1=100001651;
//ull a[100010];
//ull Hash(string s){
//    ll ans=0;
//    for(int i=0;i<s.size();i++){
//        ans*=bas;
//        ans+=int(s[i]);
//        ans%=mod1;
//    }
//    return ans;
//}

//二维哈希
//using lom=unsigned long long ;
//const lom bas1=131,bas2=233;
//const int M=505;
//int n,m;
//char a[M][M];
//lom _hash[M][M];
//lom p1[M],p2[M];
//
//
//void init(){
//    p1[0]=1;
//    p2[0]=1;
//    for(int i=1;i<=505;i++){
//        p1[i]=p1[i-1]*bas1;
//        p2[i]=p2[i-1]*bas2;
//
//    }
//}
//void Hash(){
//    _hash[0][0]=_hash[0][1]=_hash[1][0]=0;
//    for(int i=1;i<=n;i++){    //前缀和
//        for(int j=1;j<=m;j++){
//            _hash[i][j]=_hash[i][j-1]*bas1+a[i][j]-'a';
//        }
//    }
//    for(int i=1;i<=n;i++){   //二维前缀和
//        for(int j=1;j<=m;j++){
//            _hash[i][j]+=_hash[i-1][j]*bas2;
//        }
//    }
//
//}
const int MAX=10000;
struct {  //用结构体实现线段树
    int l,r,len;
}tree[MAX*4];
int pre[MAX];
int ans[MAX];
void buildtree(int left,int right,int u){ //建树
    tree[u].l=left;
    tree[u].r=right;
    tree[u].len=(right-left+1);
    if(left==right)
        return;
    buildtree(left,(right+left)>>1, u<<1); //递归左子树
    buildtree(((left+right)>>1)+1,right,(u<<1)+1); //递归右子树
}
int query(int u,int num){ //查询+维护，所求值为当前区间中左起第num个元素
    tree[u].len--; //对访问到的区间维护len 把这个节点的牛的数量-1
    if(tree[u].l==tree[u].r){
        return tree[u].l;
    }
    if(tree[u<<1].len<num)//左区间牛的数量不够
        return query((u<<1)+1, num-tree[u<<1].len);
    if(tree[u<<1].len>=num)//左区间的数量够
        return query(u<<1,num);
    return 0;
}
int main(){
    int n;
    cin>>n;
    for(int i=1;i<=n;i++) cin>>pre[i];
    buildtree(1,n,1);
    for(int i=n;i>=0;i--){
        ans[i]=query(1,pre[i]+1);
    }
    for(int i=1;i<=n;i++){
        cout<<ans[i]<<" ";
    }
}

郭晋龙
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
mystery-cows:ClojureScript + Firebase的一个简单例子
05-09
神秘牛 这是一个示例程序（棋盘游戏Clue的以牛为主题的版本），旨在演示如何使用ClojureScript和Firebase制作Web应用程序。 它部署在。 以下内容不需要使用Clojure或Firebase。 一旦运行，就可以开始浏览代码以查看...
POJ2186-Popular Cows【Tarjan+极大强连通分量+缩点】
09-09
POJ2186-Popular Cows 【Tarjan+极大强连通分量+缩点】 解题报告+AC代码 http://hi.csdn.net/!s/BGDH68 附：我所有的POJ解题报告链接 . http://blog.csdn.net/lyy289065406/article/details/6642573
GDUT专题练习5 Lost Cows 暴力解法
weixin_45917090的博客
02-22 75
题目链接:GDUT-21级第五次专题训练——树状数组，线段树 - Virtual Judge (vjudge.net) 题目大意: 有一个1,2,3,....,n(1<n<=8000)的,现在已知从第二个数开始，每一个数之前小于这个数的数的个数为(1<i<=n),求这个排列。 思路: 从前往后推没有思路，本着正难则反的原则，从后面开始推起，我们不难发现: 先想出t=[0,1,2,3,4,...,n] 最后一个数的大小就是t[+1],然后把它从t中删去 倒数第二个数的大小
POJ 2182 Lost Cows（三种解法：暴力 和 线段树 和 树状数组）
08-07 489
题意： 有n头牛，每头牛有一个序号(范围是1-n)。现在知道每头牛前面比自己序号小的牛的数量。需要求出每头牛的序号 分析： 可以想到的是，从后往前遍历。对于第i头牛，如果它前面有k头牛比它的序号小，那么它的序号就是当前仅剩编号中的第（k + 1）大的数。 暴力求法（类似约瑟夫环） 那么本题的难点就变成了如果求出剩下的编号中第m大的数，因为从后往前遍历的过程中，每确定一头牛的编号，那么剩下的编号就要去掉一个值。 这和约瑟夫环非常的类似（本题没有环），因此可以用
POJ 2182 Lost Cows （简单题，线段树）
谦卑
03-04 531
POJ 2182 Lost Cows （线段树（查询）） 题目链接： POJ 2182 Lost Cows 题目描述： 有编号1~n的n个数字，2 <= n <= 8000, 乱序排列，顺序是未知的。对于每个位置的数字，知道排在前面比它小的数字有多少个，求这个乱序数列的顺序。 题解思路： 首先用暴力的方法来求解这道题 我们知道pre【】：0 1 2 1 0 和 ans【】： 基本的思路就是从后向前来看这个pre数组，从后向前看，每次只要找到现存有的数字的第pre【i】+ 1的数字就是答案。 暴
Lost Cows（线段树）
天真有邪的博客
06-28 1509
Lost Cows 题意：给出n头牛前面有多少头比他编号少的数目，求出原来的牛的编号， 思路：从后面开始遍历，碰到的a表示此牛在剩余的牛中排名a+1.线段树维护区间里面未标记的牛的数量，找到满足条件的区间即可。找到后同时更新一下。 #include<cstdio> int sum[32005]; int a[8005],ql,qr,b[8000]; void build(in...
poj2182 Lost Cows 线段树 二分+树状数组 模板
一叶之修的博客
04-10 242
描述 N（2 <= N <= 8,000）母牛具有1..N范围内的独特品牌。在一个表现不佳的壮观表现中，他们参观了附近的“水坑”，并在晚餐前喝了几杯啤酒。当是时候排队吃晚餐时，他们没有按照品牌所需的数字顺序排列。 遗憾的是，FJ没有办法对它们进行排序。此外，他不善于观察问题。他没有记下每头牛的品牌，而是确定了一个相当愚蠢的统计数据：对于每头排队的牛，他都知道排在那头牛之前的奶牛数量...
lost cows
把复杂的事情简单描述
04-21 825
Lost Cows Time Limit: 1000MS   Memory Limit: 65536K Total Submissions: 8004   Accepted: 5100 Description N (2 <= N <= 8,000) cows have unique brands
线段树 查询删除 后序遍历 POJ2182 Lost Cows解题报告
Dafang_Xu的博客
09-01 501
线段树 查询删除 后序遍历 POJ2182 Lost Cows解题报告
POJ-2182-Lost Cows题解(树状数组 or 线段树)
还没有简介~
02-22 456
Lost Cows 题目传送门 题意 FJ有n头牛，编号 1~n ，但是这些牛并没有按照编号排队，但是 FJ 知道每头牛前面有几头编号比这头牛编号小，现在问你每头牛的编号。 题解 从最后一头牛开始，其它牛都已经在队列里，假如这头牛前面有 x 头牛编号比它小，那么这头牛就是编号第 x 小（按编号从小到大排序）的牛的编号加一。知道了这头牛的编号，就可以把这头牛从队列中赶走了，因为有没有它都不会...
poj 2182 Lost Cows
m0_57527312的博客
05-15 77
文章目录题目分析：AC代码：暴力解法：线段树解法： 题目地址 题目分析： 其实就是找1~n的原序列， 题目提供长为n的序列，每个元素代表这个数在原序列中其前面有多少个小于它的元素。 AC代码： 暴力解法： //#include<bits/stdc++.h> #include<iostream> #include<vector> #include<algorithm> using namespace std; const int N=8009; int a
cows:Swift Swift的ASCII母牛
05-28
牛 400+ ASCII :cow_face: s 该列表只是一个字符串数组，可以在任何地方使用。例子 (__) (oo) /-------\/ / | ||+ ||----|| ~~ ~~ Cow \(:)/ (o|o) /-----\_/ /| |^ ||----|| ^^ ^^ Klingon Cow ________________ ^_...
USACO题目Milking Cows及代码解析
10-23
### USACO 题目解析：Milking Cows #### 题目背景与要求 本题目来源于美国计算机奥林匹克竞赛（USACO），题目名为“Milking Cows”。题目描述了一个有趣的场景：三位农民每天早上给三头牛挤奶，并给出了各自的挤奶...
Cows_Bulls_2020
02-20
《Cows & Bulls游戏在C++中的实现》 "Cows_Bulls_2020"是一个基于C++编程语言的游戏项目，它很可能是指经典的“数牛数马”（Cows and Bulls）游戏。这个游戏通常是一种数字猜谜游戏，玩家需要猜测一个由随机数字...
CSS学习 01 利用鼠标悬停制造文本隐藏效果
weixin_57266891的博客
08-02 313
以下HTML代码包含三个帖子，每个帖子都有一个剧透部分。：文本颜色恢复为初始值（通常是默认颜色）。：表示文档的根元素。定义了一个CSS变量。：背景色恢复为初始值（无背景色）。：设置行高为1.5倍的字高。：所有样式变化在0.5秒内以。（黑色），导致文本不可见。：文本颜色使用同一个变量。这些剧透部分被包含在。：背景色使用定义的变量。：当鼠标悬停在类名为。
项目中万能使用tailwindcss，无版本冲突、报错
xxx
08-02 107
新建两个css文件tailwindInput.css、tailwindOutput.css。
前端的学习-CSS（弹性布局-flex）
最新发布
m0_68823256的博客
08-02 964
CSS的定位-给父元素设置的属性
web基础之CSS
Yunzhong_jiuxiao的博客
08-02 830
css属性
COWS符号语义：面向服务计算的动态行为建模与工具应用
COWS的符号语义提供了一种更为严谨和形式化的途径，使得服务间的交互能够通过符号表示和自动化工具进行分析，这对于保证系统的正确性、性能优化以及适应不断变化的业务需求至关重要。同时，COWS的发展也得益于多个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

郭晋龙

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值