滴滴算法岗笔试A了第一道,贴代码攒人品。。。

更新一下:

许多小伙伴都发现了一个问题,就是遇到类似2 * 3 / -2、 3 * 1 + 1这种式子这套代码的输出就不对了。

一开始楼主也想过这种可能,不过鉴于太复杂所以只先写了简单版本的代码,结果发现也ac了。说明出题人可能就没考虑过这种情况。。。

这个也算是题目的一个小bug把,如果真把这种情况算进去了,那么要考虑的情况会变得无比复杂,关于这种情况的解决方案欢迎大家一起讨论哈

-----------------------------------------------------------------------------------------------------------------------------------

题目描述:
给出一个仅包含加减乘除四种运算符的算式(不含括号),如1+2*3/4,在保持运算符顺序不变的情况下,现在你可以进行若干次如下操作:如果交换相邻的两个数,表达式值不变,那么你就可以交换这两个数。

现在你可以进行任意次操作,使得算式的数字序列字典序最小,然后输出结果,数字之间的字典序定义为若a<b则a的字典序小于b。

输入
第一行包含一个整数n,表示算式的长度,即包含n个数字和n-1个运算符。(1≤n≤100000)。

第二行包含一个含有n个非0整数和n-1个运算符的算式,整数与运算符用空格隔开,运算符包括“+-*/”,整数的绝对值不超过1000。

输出
按要求输出字典序最小的表达式,数字与符号之间用空格隔开。

样例输入
6
3 + 2 + 1 + -4 * -5 + 1
样例输出
1 + 2 + 3 + -5 * -4 + 1

以下思路是个人想的,不保证是最优解。
思路:
先用两个数组来存储数字(nums)和这个数字之前的操作符(ops)。其中ops第一个元素固定是'+',因为第一个数没有符号。例如样例就会得到如下的两个数组:

索引 0 1 2 3 4 5
nums 3 2 1 -4 -5 1
ops + + + + * +

接着用两个指针 l 和 r,一段一段地找ops中连续的操作符,例如样例中就会得出“l=0,r=3; l=4,r=4; l=5,r=5”三段。
接着根据一套规则来确定 l 和 r 区间内哪些元素是需要进行排序,以实现字典序最小:
  • 如果ops[l]是加号或减号
  1. 这段区间下一个操作符是'*'或者‘/’,那么要排序的区间是[l, r-1]; 想想类似5+4+3+2+1*5的情况
  2. 段区间下一个操作符是'-',那么要排序的区间是[l, r];想想类似5+4+3+2+1-5的情况
  • ops[l]是乘号
  1. 区间前一个操作符是'+'或者‘-’,那么要排序的区间是[l-1, r];想想类似1+5*4*3*2*1的情况
  2. 区间前一个操作符是‘/’,那么要排序的区间是[l, r];想想类似1/5*4*3*2*1的情况
  • ops[l]是除号
  1. 不论什么情况,要排序的区间都是[l, r];
以上遍历一套,就可以得到答案了

代码:
int Partition(vector<int>& nums, int left, int right) {
	int pivot = nums[left], l = left + 1, r = right;
	while (l <= r) {
		if (nums[l] > pivot && nums[r] < pivot)
			swap(nums[l], nums[r]);
		if (nums[l] <= pivot) l++;
		if (nums[r] >= pivot) r--;
	}
	swap(nums[left], nums[r]);
	return r;
}

void QuickSort(vector<int> &nums, int lo, int hi) {
	if (hi <= lo) return;
	int seg = Partition(nums, lo, hi);
	QuickSort(nums, lo, seg - 1);
	QuickSort(nums, seg + 1, hi);
}

int main(){
    int n; cin>>n;
    vector<int> nums(n, 0);
    vector<char> ops(n, '+');
    for(int i=0; i<n-1; ++i){
        cin >> nums[i];
        cin >> ops[i+1];
    }
    cin >> nums[n-1];

    int l=0, r=0;
    while(r<n){
        while(r<n && ops[r] == ops[l]) ++r;
        --r;
        if(ops[l] == '+' || ops[l] == '-'){
            if(r<n-1 && (ops[r+1]=='*' || ops[r+1]=='/'))
                QuickSort(nums, l, r-1);
            else
                QuickSort(nums, l, r);
            
        }
        else if(ops[l] == '*'){
            if(l>0 && (ops[l-1]=='+' || ops[l-1]=='-'))
                QuickSort(nums, l-1, r);
            else
                QuickSort(nums, l, r);
        }
        else if(ops[l] == '/'){
            QuickSort(nums, l, r);
        }
        ++r; l=r;
    }
    
    string ans = to_string(nums[0]);
    for(int i=1; i<n; ++i){
        ans.push_back(' ');
        ans.push_back(ops[i]);
        ans.push_back(' ');
        ans += to_string(nums[i]);
    }
    cout<<ans<<endl;
    return 0;
} 

通过率:100%

#滴滴##笔试题目##秋招##题解#
全部评论
楼主还自己实现了快排,太强了吧😂,为啥不用sort
点赞 回复 分享
发布于 2019-08-27 21:57
tql,我当时想着分类讨论,想着想着思路就乱了,还要思路清晰、有条不紊地用代码实现出来,脑子已经一团乱麻了。基于楼主大佬的思路,我改写了个更简洁点的版本。 #include <iostream> #include <vector> using namespace std; int n; void QuickSort(vector<int>& nums, int left, int right){     if(left >= right) return;     int pivot = nums[left], l = left, r = right;     while(l < r){         while(l < r && nums[r] > pivot) --r;         while(l < r && nums[l] <= pivot) ++l;         swap(nums[l], nums[r]);     }     swap(nums[left], nums[r]);     QuickSort(nums, left, r-1);     QuickSort(nums, r+1, right); } int main(){     cin >> n;     vector<int> nums(n, 0);     vector<char> ops(n, '+');     for(int i=0; i<n-1; ++i){         cin >> nums[i];         cin >> ops[i+1];     }     cin >> nums[n-1];     int l = 0, r = 0;     while(r < n){         while(r < n && ops[r] == ops[l]) ++r;         if(ops[l] == '+' || ops[l] == '-'){             if(r < n && (ops[r] == '*' || ops[r] == '/')) QuickSort(nums, l, r-2);             else QuickSort(nums, l, r-1);         }else if(ops[l] == '*'){             if(l > 0 && (ops[l-1] == '+' || ops[l-1] == '-')) QuickSort(nums, l-1, r-1);             else QuickSort(nums, l, r-1);         }else if(ops[l] == '/'){             QuickSort(nums, l, r-1);         }         l = r;     }     cout << nums[0];     for(int i=1; i<n; ++i) cout << ' ' << ops[i] << ' ' << nums[i];     return 0; }
点赞 回复 分享
发布于 2019-08-28 15:44
中间还有空格么 😂😂😂卧槽?
点赞 回复 分享
发布于 2019-08-27 21:21
思路不错,强
点赞 回复 分享
发布于 2019-08-27 21:23
tql
点赞 回复 分享
发布于 2019-08-27 21:26
思路太清晰了,tql
点赞 回复 分享
发布于 2019-08-27 21:37
我也是这样的思路 可是我没写出代码来 我太菜了
点赞 回复 分享
发布于 2019-08-27 21:38
大佬牛X,我也是这么想的,但是讨论不清楚了 。
点赞 回复 分享
发布于 2019-08-27 21:52
我的第一直觉是要借助树进行算式的后缀表达,然后全程在写树🤣
点赞 回复 分享
发布于 2019-08-27 21:53
tql!!
点赞 回复 分享
发布于 2019-08-27 21:54
tql,思路很清楚
点赞 回复 分享
发布于 2019-08-27 21:56
我有一个疑问,就是连续的-或者/是可以交换的嘛?  比如 1-2-3 是不能排序的吧?  同理 1/2/3也是不能排序的吧?
点赞 回复 分享
发布于 2019-08-27 21:56
好吧,我把/周围的数字也给排序了。。最后只通过了18%。。
点赞 回复 分享
发布于 2019-08-27 21:56
思路清晰!强
点赞 回复 分享
发布于 2019-08-27 21:59
考虑n个数对应n-1个运算符。从已知的运算结果往回算,排列组合,每次从n里面选一个数,从n-1里面选一个运算符(这里做逆运算),深度遍历标记已经访问过的数和运算符,最后剩下的一个数如果等于当前值,就把这个序列加入结果集,如果有字典序比他小的就替换。
点赞 回复 分享
发布于 2019-08-27 22:05
小哥哥问个问题, ops[i]为除号时,为啥要排序区间不是[l+1,r]呢,第一个数不是被除数吗。
点赞 回复 分享
发布于 2019-08-27 22:14
一样的思路,然鹅没码出来🤣
点赞 回复 分享
发布于 2019-08-27 22:24
问一下,c++ 中的字符串+和Push_back的区别
点赞 回复 分享
发布于 2019-08-27 22:26
其实这个代码,单纯针对题意来说还是有点问题的,题意只是要求不改变符号顺序。 对于特殊的情况,如: 输入: 5 9 * 4 + 10 + 2 * 1 程序输出: 4 * 9 + 10 + 1 * 2 满足题意的最小字典序输出应为: 1 * 2 + 10 + 4 * 9
点赞 回复 分享
发布于 2019-08-27 22:28
是个大佬  tql
点赞 回复 分享
发布于 2019-08-27 22:31

相关推荐

牛客146600443号:92的能看上这3k,5k在搞笑呢
点赞 评论 收藏
分享
点赞 评论 收藏
分享
牛客339922477号:都不用reverse,直接-1。一行。啥送分题
点赞 评论 收藏
分享
42 164 评论
分享
牛客网
牛客企业服务