1.为了不断优化推荐效果，今日头条每天要存储和处理海量数据。假设有这样一种场景：我们对用户按照它们的注册时间先后来标号，对于一类文章，每个用户都有不同的喜好值，我们会想知道某一段时间内注册的用户（标号相连的一批用户）中，有多少用户对这类文章喜好值为k。因为一些特殊的原因，不会出现一个查询的用户区间完全覆盖另一个查询的用户区间(不存在L1<=L2<=R2<=R1)。
输入描述:
输入： 第1行为n代表用户的个数 第2行为n个整数，第i个代表用户标号为i的用户对某类文章的喜好度 第3行为一个正整数q代表查询的组数 第4行到第（3+q）行，每行包含3个整数l,r,k代表一组查询，即标号为l<=i<=r的用户中对这类文章喜好值为k的用户的个数。 数据范围n <= 300000,q<=300000 k是整型
输出描述:
输出：一共q行，每行一个整数代表喜好值为k的用户的个数
输入
5 1 2 3 3 5 3 1 2 1 2 4 5 3 5 3
输出
1 0 2
解析:考虑到会有很多查询。则输入数组设置为：vector<node>vec，其中node一个是喜好值val,一个是index当前索引，然后按照val对vec进行排序，这样就会把同一个val的相邻。然后用一个map记录每个不同的val的初始索引，当查询一个val的时候，只需要根据map中val的初始索引，在vec中向后查找，统计index在给定的left值和right范围内的个数即可，这么做为了避免每次查询一个val,就会遍历很多数。代码如下：
#include<iostream>
#include<vector>
#include<unordered_map>
#include<algorithm>
using namespace std;
typedef struct __tagNode
{
int val;
int index;
__tagNode(int x, int y)
{
val = x;
index = y;
}
}Node;
class less_to_greater
{
public:
bool operator()(Node &x, Node &y)
{
return x.val<y.val;
}
};
int main()
{
int n;
cin >> n;
vector<Node>vec(n, Node(0, 0));
for(int i=0; i<n; ++i)
{
cin >> vec[i].val;
vec[i].index = i;
}
// 排序
sort(vec.begin(), vec.end(), less_to_greater());
// 记录位置
unordered_map<int, int>ma;
for(int i=0; i<n; ++i)
{
if(ma.count(vec[i].val) < 1)
ma[vec[i].val] = i;
}
// 开始查询
int q;
cin >> q;
while(q)
{
int l, r, k;
cin >> l >> r >> k;
if(l>r || ma.count(k) < 1)
{
cout << 0 << endl;
--q;
continue;
}
--l;
--r;
int i = ma[k];
int res = 0;
while(i<n && vec[i].val == k)
{
if(vec[i].index >= l && vec[i].index <= r)
++res;
++i;
}
cout << res << endl;
--q;
}
return 0;
}2.作为一个手串艺人，有金主向你订购了一条包含n个杂色串珠的手串——每个串珠要么无色，要么涂了若干种颜色。为了使手串的色彩看起来不那么单调，金主要求，手串上的任意一种颜色（不包含无色），在任意连续的m个串珠里至多出现一次（注意这里手串是一个环形）。手串上的颜色一共有c种。现在按顺时针序告诉你n个串珠的手串上，每个串珠用所包含的颜色分别有哪些。请你判断该手串上有多少种颜色不符合要求。即询问有多少种颜色在任意连续m个串珠中出现了至少两次。
输入描述:
第一行输入n，m，c三个数，用空格隔开。(1 <= n <= 10000, 1 <= m <= 1000, 1 <= c <= 50) 接下来n行每行的第一个数num_i(0 <= num_i <= c)表示第i颗珠子有多少种颜色。接下来依次读入num_i个数字，每个数字x表示第i颗柱子上包含第x种颜色(1 <= x <= c)
输出描述:
一个非负整数，表示该手链上有多少种颜色不符需求。
输入
5 2 3 3 1 2 3 0 2 2 3 1 2 1 3
输出
2
解析：模拟计算即可。有两点我做的处理，1、使用vector<unordered_set<int>>vec来存储每个珠子的颜色，外面的vec[i]代表每个珠子，而每个vec[i]都是一个set集，代表当前珠子的颜色集，使用set方便查找某个颜色存不存在。2.因为考虑到了珠子颜色不在某个间距内重复是个环的问题，所以当不在m步内出现时，直接把输入数组vec的前m-1项复制一遍插入到vec后面，就不用理会环的问题处理了。代码如下：
#include<iostream>
#include<vector>
#include<unordered_set>
using namespace std;
int main()
{
int n, m, clo;
cin >> n >> m >> clo;
vector<unordered_set<int>> vec(n);;
for(int i=0; i<n; ++i)
{
int num;
cin >> num;
int temp = 0;
for(int j=0; j<num; ++j)
{
cin >> temp;
vec[i].insert(temp);
}
}
for(int i=0; i<m-1; ++i)
vec.push_back(vec[i]);
int size = vec.size();
int res = 0;
for(int i=1; i<=clo; ++i)
{
for(int j=0; j<=size-m; )
{
int r = -1;
bool bFind = false;
int count = 0;
for(int k=j; k<j+m; ++k)
{
if(vec[k].count(i) < 1)
{
if(count == 0)
r = k;
}
else
{
++count;
if(count > 1)
{
++res;
bFind = true;
break;
}
}
}
if(bFind)
break;
if(j+1 < r)
j = r;
else
++j;
}
}
cout << res << endl;
return 0;
}3. 字符串S由小写字母构成，长度为n。定义一种操作，每次都可以挑选字符串中任意的两个相邻字母进行交换。询问在至多交换m次之后，字符串中最多有多少个连续的位置上的字母相同？
输入描述:
第一行为一个字符串S与一个非负整数m。(1 <= |S| <= 1000, 1 <= m <= 1000000)
输出描述:
一个非负整数，表示操作之后，连续最长的相同字母数量。
输入
abcbaa 2
输出
2
说明
使2个字母a连续出现，至少需要3次操作。即把第1个位置上的a移动到第4个位置。 所以在至多操作2次的情况下，最多只能使2个b或2个a连续出现。
解析：这道理直接做很复杂。用动态规划还是省很多事，但是用动态规划不是直接解决问题，求出答案。需要对字符串中每个字符c出现的位置集，进行动态规划，求出字符c的字符连续，所需要的代价步数，选出小于给定步数，并且连续的字符C最多的，同理，对每个字符都做这一边操作，最终能够找出小于给定代价步数并且连续最多的字符和它的连续个数。
核心的动态规划思路：提取出相同字符的位置，比如ababa中a的位置为（0，2，4），b的位置为（1，3）。对每个位置向量用动态规划求解。
字符a的位置数组为arr，动态规划过程：
dp(i,j)表示字符a第i个位置到第j个位置的字符要全部相邻，至少要用需要多少次交换。
1. i==j时，表示一个字符，不用交换，dp(i,j)为0；
2. i+1==j时，表示两个字符，位置相差arr[j]-arr[i]；
3.其他情况，dp(i,j) = dp(i+1,j-1) + arr[j]-arr[i] - (j - i)；
思路:
首先思考下第3种转移。因为[i+1,j-1]之间已经成了一个连续的段，所以左右两边都是往中间靠的，不管
怎么靠，交换的次数肯定都一样。
代码如下：
#include<iostream>
#include<vector>
#include<string>
#include<unordered_map>
#include<iterator>
using namespace std;
int main()
{
string str = "";
int m;
cin >> str;
cin >> m;
unordered_map<char, int>ma;
int size = str.size();
for(int i=0; i<size; ++i)
{
if(ma.count(str[i]) > 0)
++ma[str[i]];
else
ma[str[i]] = 1;
}
int res = 1;
unordered_map<char, int> :: iterator it = ma.begin();
while(it != ma.end())
{
if(it->second < res)
{
++it;
continue;
}
int num = it->second;
char c = it->first;
vector<vector<int>>dp(num, vector<int>(num, 0));
vector<int> vec;
for(int i=0; i<size; ++i)
{
if(str[i] == c)
vec.push_back(i);
}
for(int j=1; j<num; ++j)
{
for(int i=0; i+j<num; ++i)
{
if(j == 1)
dp[i][i+j] = vec[i+j]-vec[i];
else
{
dp[i][i+j] = dp[i+1][i+j-1] + vec[i+j]-vec[i] - (j);
}
}
}
for(int i=0; i<num; ++i)
{
for(int j=i+1; j<num; ++j)
{
if(dp[i][j] <= m && (j-i+1 > res))
res = j-i+1;
}
}
++it;
}
cout << res << endl;
return 0;
}
扫一扫
4616
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
