65,186
社区成员
发帖
与我相关
我的任务
分享求助，关于csdn的英雄会的一个题目，微软出的那个。
题目链接：
http://hero.csdn.net/Question/Details?ID=624&ExamID=619&from=4
这个题目我用c++写的，给出的用例我跑了ok的，然后我提交了，告诉我运行结束，结果和期望不符，失败了。
本来是闲的练练手，结果被搞的郁闷了，就想一探究竟。唉。
发帖的目的就是想知道，亲，怎么知道他的test case？
比赛还没有结束吧，所以不好贴全部的代码，过几天贴出来吧。
http://hero.csdn.net/Question/Details?ID=624&ExamID=619&from=4
这个题目我用c++写的，给出的用例我跑了ok的，然后我提交了，告诉我运行结束，结果和期望不符，失败了。
本来是闲的练练手，结果被搞的郁闷了，就想一探究竟。唉。
发帖的目的就是想知道，亲，怎么知道他的test case？
比赛还没有结束吧，所以不好贴全部的代码，过几天贴出来吧。
...全文
请发表友善的回复…
发表回复
阿呆_ 2014-07-25
- 打赏
- 举报
不考虑效率的话实现很简单。将C视为字符串即可，每个字符对应一个core, 比如'F'表示未分配，'A'表示已分配，可以将分配请求生成一个子串，比如A 3生成一个"FFF", 分配就是搜索M个字符串中第一个满足条件的子串而已，然后将其相应位置替换成"AAA"。 也许优化可以从字符串搜索入手。
赵4老师 2014-07-24
- 打赏
- 举报
仅供参考
//实现一个函数：求数轴上多个线段覆盖的区域对应的多个线段; 输入多个线段,求出被这些线段覆盖的所有区域(也用线段表示); 一条线段用两个值表示(x0,x1), 其中x1>x0;
//比如(1,3);(2,4);(5,6);结果为(1,4);(5,6);
//比如(1,3);(2,4);(5,6);(4,7);结果为(1,7);
#include <stdio.h>
#define MAXLINES 100
struct LINE {
int x0;//左端
int x1;//右端
} ls[MAXLINES];
int i,j,k,n,x0,x1,c;
void add() {
if (0==n) {//加入第一对点
ls[n].x0=x0;
ls[n].x1=x1;
n=1;
} else {
if (x1==ls[0].x0) {//右端＝第一条线段的左端
ls[0].x0=x0;//第一条线段的左端修改为左端
return;
}
if (x1<ls[0].x0) {//右端＜第一条线段的左端
for (i=n-1;i>=0;i--) {//将所有线段往后移
ls[i+1].x0=ls[i].x0;
ls[i+1].x1=ls[i].x1;
}
ls[0].x0=x0;//新第一条线段为x0,x1
ls[0].x1=x1;
n++;
return;
}
if (ls[n-1].x1<x0) {//左端＞最后那条线段的右端
ls[n].x0=x0;//新最后那条线段
ls[n].x1=x1;
n++;
return;
}
if (x0<=ls[0].x0 && ls[n-1].x1<=x1) {//左端≤第一条线段的左端且最后那条线段的右端≤右端
ls[0].x0=x0;//只剩这一条线段
ls[0].x1=x1;
n=1;
return;
}
for (i=0;i<n;i++) {//从左到右依次检查每条线段
if (ls[i].x0<=x0 && x0<=ls[i].x1) {//第i条线段的左端≤左端≤第i条线段的右端
for (j=i;j<n;j++) {//从第i条线段开始从左到右依次检查每条线段
if (ls[j].x0<=x1 && x1<=ls[j].x1) {//第j条线段的左端≤右端≤第j条线段的右端
ls[i].x1=ls[j].x1;//第i条线段的右端改为第j条线段的右端
for (k=1;k<=n-j-1;k++) {//将剩余线段往前移
ls[i+k].x0=ls[j+k].x0;
ls[i+k].x1=ls[j+k].x1;
}
n-=j-i;
return;
}
if (ls[j].x1<x1 && (j==n-1 || x1<ls[j+1].x0)) {//第j条线段的右端＜右端＜第j+1条线段的左端(如果有)
ls[i].x1=x1;//第i条线段的右端改为右端
for (k=1;k<=n-j-1;k++) {//将剩余线段往前移
ls[i+k].x0=ls[j+k].x0;
ls[i+k].x1=ls[j+k].x1;
}
n-=j-i;
return;
}
}
}
if (ls[i].x1<x0 && (i==n-1 || x0<ls[i+1].x0)) {//第i条线段的右端＜左端＜第i+1条线段的左端(如果有)
if (i!=n-1 && x1<ls[i+1].x0) {//右端＜第i+1条线段的左端(如果有)
for (k=n-1;k>=i+1;k--) {//将从第i+1条线段开始的所有线段往后移
ls[k+1].x0=ls[k].x0;
ls[k+1].x1=ls[k].x1;
}
ls[i+1].x0=x0;//新第i+1条线段为x0,x1
ls[i+1].x1=x1;
n++;
return;
}
for (j=i+1;j<n;j++) {//从第i+1条线段开始从左到右依次检查每条线段
if (ls[j].x0<=x1 && x1<=ls[j].x1) {//第j条线段的左端≤右端≤第j条线段的右端
ls[i+1].x0=x0;//第i+1条线段的左端改为左端
ls[i+1].x1=ls[j].x1;//第i+1条线段的右端改为第j条线段的右端
for (k=1;k<=n-j-1;k++) {//将剩余线段往前移
ls[i+1+k].x0=ls[j+k].x0;
ls[i+1+k].x1=ls[j+k].x1;
}
n-=j-i-1;
return;
}
if (ls[j].x1<x1 && (j==n-1 || x1<ls[j+1].x0)) {//第j条线段的右端＜右端＜第j+1条线段的左端(如果有)
ls[i+1].x0=x0;//第i+1条线段的左端改为左端
ls[i+1].x1=x1;//第i+1条线段的右端改为右端
for (k=1;k<n-j-1;k++) {//将剩余线段往前移
ls[i+k].x0=ls[j+k].x0;
ls[i+k].x1=ls[j+k].x1;
}
n-=j-i-1;
return;
}
}
}
if (x0<ls[i].x0) {//左端＜第i条线段的左端
for (j=i;j<n;j++) {//从第i条线段开始从左到右依次检查每条线段
if (ls[j].x0<=x1 && x1<=ls[j].x1) {//第j条线段的左端≤右端≤第j条线段的右端
ls[i].x0=x0;//第i条线段的左端改为左端
ls[i].x1=ls[j].x1;//第i条线段的右端改为第j条线段的右端
for (k=1;k<=n-j-1;k++) {//将剩余线段往前移
ls[i+k].x0=ls[j+k].x0;
ls[i+k].x1=ls[j+k].x1;
}
n-=j-i;
return;
}
if (ls[j].x1<x1 && (j==n-1 || x1<ls[j+1].x0)) {//第j条线段的右端＜右端＜第j+1条线段的左端(如果有)
ls[i].x0=x0;//第i条线段的左端改为左端
ls[i].x1=x1;//第i条线段的右端改为右端
for (k=1;k<=n-j-1;k++) {//将剩余线段往前移
ls[i+k].x0=ls[j+k].x0;
ls[i+k].x1=ls[j+k].x1;
}
n-=j-i;
return;
}
}
}
}
}
}
void show() {
for (i=0;i<n;i++) {
printf("(%d,%d);",ls[i].x0,ls[i].x1);
}
printf("\n");
}
void main() {
n=0;
c=0;
while (1) {
printf("Input x0,x1(x0<x1;0,0 to exit):");
fflush(stdout);
rewind(stdin);
if (2==scanf("%d,%d",&x0,&x1)) {
if (0==x0&&0==x1) break;
if (x1>x0) {
c++;
if (c>=MAXLINES) {
printf("Up to %d!\n",MAXLINES);
break;
}
add();
show();
}
}
}
}
就呆在云上 2014-07-24
- 打赏
- 举报
#include <iostream>
#include <vector>
#include <algorithm>
#include <string>
#include <set>
#include <list>
using namespace std;
enum Action
{
Ask = 1,
Free,
};
bool EQ(const pair <Action , int > &in )
{
if(in.first == Ask)
return true;
return false;
}
struct QMC
{
int mIndex; // Machine index
int coreLeft; // in fact left cores
int coreStart; // last left
bool operator == ( const QMC & in) const
{
if(mIndex == in.mIndex && coreLeft == in.coreLeft && coreStart == in.coreStart)
{
return true;
}
return false;
}
};
void PR(const QMC &in )
{
if(in.mIndex > 0)
cout << in.mIndex << ' ' << in.coreStart << "\r\n";
else
cout << -1 << ' ' << -1 << "\r\n";
}
struct MC
{
int mIndex;
int maxSliceCount;
list<QMC> freeList;
QMC getCores(const int size);
void insertList(const QMC &in);
};
struct cmpMCLess
{
bool operator ()(const MC *l, const MC *r) const
{
if(l->mIndex < r->mIndex)
return true;
return false;
}
};
class coresLeftBenchMark
{
private:
vector<set<MC *, cmpMCLess> > m_coresLeftBenchMark; // build 128 line for each counter query...
public:
coresLeftBenchMark(const int &size)
:m_coresLeftBenchMark( size + 1, set<MC *, cmpMCLess>() )
{
}
set<MC *, cmpMCLess>::iterator get(const int &size)
{
return m_coresLeftBenchMark[size].begin();
}
set<MC *, cmpMCLess>::iterator getEnd(const int &size)
{
return m_coresLeftBenchMark[size].end();
}
void add(MC *in);
void resize(MC *in, int fromSize, int toSize);
};
void coresLeftBenchMark ::add(MC *in )
{
for(int i = 1; i <= in->maxSliceCount; i++)
{
m_coresLeftBenchMark[i].insert(in);
}
}
void coresLeftBenchMark ::resize(MC *in, int fromSize, int toSize)
{
if(fromSize == toSize)
return;
if(fromSize < toSize)
{
for(int i = fromSize + 1; i <= toSize; i++)
{
m_coresLeftBenchMark[i].insert(in);
}
}
if(fromSize > toSize)
{
for(int i = toSize + 1; i <= fromSize; i++)
{
m_coresLeftBenchMark[i].erase(in);
}
}
}
class CMsTest
{
private:
const static int machineCoreMax = 128;
MC *mcArr;
coresLeftBenchMark m_coresLeftBenchMark; // build 128 line for each counter query...
vector<QMC> coresAsked;
vector<pair<Action, int> > actions;
public:
CMsTest()
:m_coresLeftBenchMark(machineCoreMax + 1)
{
mcArr = NULL;
}
~CMsTest()
{
delete []mcArr;
}
void init(vector<int> &in_cores, vector<pair<Action, int> > & in_actions)
{
int coreSize = in_cores.size();
mcArr = new MC[coreSize];
for(int i = 0; i < coreSize; i++)
{
QMC mc = {i + 1, in_cores[i], 1};
mcArr[i].mIndex = i + 1;
mcArr[i].maxSliceCount = in_cores[i];
mcArr[i].freeList.push_back(mc);
m_coresLeftBenchMark.add(mcArr + i);
}
coresAsked.reserve(in_actions.size()/2);
actions.swap( in_actions);
in_cores.clear();
in_actions.clear();
}
void calculate()
{
vector<pair<Action, int> >::reverse_iterator iter = find_if(actions.rbegin(), actions.rend(), EQ);
actions.erase(iter.base(), actions.end());
for(vector<pair<Action, int> >::iterator iter = actions.begin(); iter != actions.end(); iter++)
{
pair< Action, int> &i_pair = *iter;
if(i_pair.first == Ask)
{
if(i_pair.second > machineCoreMax)
{
QMC objAsk = {0};
coresAsked.push_back(objAsk);
continue;
}
set<MC*, cmpMCLess>::iterator iter = m_coresLeftBenchMark.get(i_pair.second);
if(iter != m_coresLeftBenchMark.getEnd(i_pair.second))
{
MC *pmc = *iter;
int preMax = pmc->maxSliceCount;
QMC obj = pmc->getCores(i_pair.second);
QMC objAsk = obj;
objAsk.coreLeft = i_pair.second;
coresAsked.push_back(objAsk);
m_coresLeftBenchMark.resize(pmc, preMax, pmc->maxSliceCount);
}
else
{
QMC objAsk = {0};
coresAsked.push_back(objAsk);
}
}
else
{
int mIndex = coresAsked[i_pair.second - 1].mIndex;
if(mIndex > 0)
{
MC *pmc = &mcArr[mIndex - 1];
int preMax = pmc->maxSliceCount;
pmc->insertList(coresAsked[i_pair.second - 1]);
m_coresLeftBenchMark.resize(pmc, preMax, pmc->maxSliceCount);
}
}
}
}
void outPut()
{
for_each(coresAsked.begin(), coresAsked.end(), PR);
}
};
int main()
{
int testCount = 0;
cin >> testCount;
if(testCount < 1 || testCount > 20)
return 0;
CMsTest *memTest = new CMsTest[testCount];
vector<int> cores;
vector<pair<Action, int> > query;
for(int i = 0; i < testCount; i++)
{
int M, Q;
cin >> M >> Q;
cores.reserve(M);
query.reserve(Q);
while(M--)
{
int C;
cin >> C;
cores.push_back(C);
}
while(Q--)
{
int C;
string act;
cin >> act >> C;
if(act == "A")
{
query.push_back(make_pair( Ask, C));
}
else if(act == "F")
{
query.push_back(make_pair( Free, C));
}
else
{
continue;
}
}
memTest[i].init(cores, query);
memTest[i].calculate();
}
for(int i = 0; i < testCount; i++)
{
cout << "Case #" << i + 1 << ":\r\n";
memTest[i].outPut();
}
delete []memTest;
return 0;
}
QMC MC::getCores(const int size)
{
int tempCount = 0;
QMC obj;
for(list<QMC>::iterator iter = freeList.begin(); iter != freeList.end(); iter++)
{
if(iter->coreLeft >= size)
{
obj = *iter;
tempCount = iter->coreLeft;
iter->coreLeft -= size;
iter->coreStart += size;
if(iter->coreLeft == 0)
{
freeList.erase(iter);
}
break;
}
}
if(tempCount >= maxSliceCount)
{
int max = 0;
for(list<QMC>::iterator iter = freeList.begin(); iter != freeList.end(); iter++)
{
if(iter->coreLeft > max)
{
max = iter->coreLeft;
}
}
maxSliceCount = max;
}
return obj;
}
void MC::insertList(const QMC &in)
{
if(freeList.empty())
{
freeList.push_back(in);
maxSliceCount = in.coreLeft;
return;
}
for(list<QMC>::iterator iter = freeList.begin(); iter != freeList.end(); iter++)
{
if(in.coreStart < iter->coreStart)
{
list< QMC>:: iterator insIter = freeList.insert(iter, in);
list< QMC>:: iterator insIterTemp = insIter;
list< QMC>:: iterator cIter = insIter;
list< QMC>:: iterator nIter = ++insIter;
QMC prv = {0, 0, 0};
QMC cur = *cIter;
QMC nxt = {0, 0, 0};
if(cIter != freeList.begin())
prv = *--insIterTemp;
if(nIter != freeList.end())
nxt = *nIter;
if( prv.coreStart + prv.coreLeft == cur.coreStart &&
cur.coreStart + cur.coreLeft == nxt.coreStart)
{
freeList.erase(nIter);
freeList.erase(cIter);
prv.coreLeft += (cur.coreLeft + nxt.coreLeft);
insIterTemp->coreLeft = prv.coreLeft;
if(insIterTemp->coreLeft > maxSliceCount)
{
maxSliceCount = insIterTemp->coreLeft;
}
}
else if( prv.coreStart + prv.coreLeft == cur.coreStart)
{
freeList.erase(cIter);
prv.coreLeft += cur.coreLeft;
insIterTemp->coreLeft = prv.coreLeft;
if(insIterTemp->coreLeft > maxSliceCount)
{
maxSliceCount = insIterTemp->coreLeft;
}
}
else if(cur.coreStart + cur.coreLeft == nxt.coreStart)
{
freeList.erase(nIter);
cur.coreLeft += nxt.coreLeft;
cIter->coreLeft = cur.coreLeft;
if(cIter->coreLeft > maxSliceCount)
{
maxSliceCount = cIter->coreLeft;
}
}
break;
}
}
}
赵4老师 2014-07-24
- 打赏
- 举报
你如何知道我做村官了？[/quote]
（码）农民不都受村长（官）领导嘛。
就呆在云上 2014-07-24
- 打赏
- 举报
你说的对，复杂的地方就在这里。我反正怎么搞都没有成功，之前结果错误，然后修改了实现，就无法输出了。估计还是效率问题。
发出来我的垃圾代码，希望可以高手指点以下。
阿呆_ 2014-07-24
- 打赏
- 举报
这题的难点应该是如何排序，每次分配时最多需要访问128*10000个节点，所以遍历搜索不可取，必须排序。这里有3个关键字段：机器号（1-10000），内核号（1-128），连续空闲数量（1-128），而每次给出的搜索条件只有连续空闲数量（比如A 10 -- 分配连续10个core），必须找出匹配的最小机器号+最小内核号，这里的最大问题是如何排序，一般思考总是按搜索条件排序，比如用最大空闲数量+机器号+内核号这样的顺序排序，但是按题目要求这样排序并不能找到合适结果，因为比如你需要分配连续10个core，而满足条件的可能有第300号机器第7内核开始有10个core空闲，第5000机器第50内核开始有10个空闲，第156号机器第3内核开始有100个空闲，按题目要求，匹配的是（156，3）而不是排序之后得到的结果（300，7），而如果用机器号+空闲数+内核号排序，因为输入条件只有一个空闲数，所以还是必须遍历搜索。
就呆在云上 2014-07-23
- 打赏
- 举报
你如何知道我做村官了？就呆在云上 2014-07-23
- 打赏
- 举报
There are M machines, in which the i-th machine has Ci cores (i starts from 1). On each machine, cores are structured in a line.
有M台机器，第i台机器拥有的核数量为Ci（至少为1），每台机器的cores连续并排。
There are Q queries of the following types to serve:
1. Ask for k cores. We have to find the first machine (with theleast index) such that it has k free continuous cores and allocate themto customer. If there is a solution, return the result (m, c), in which m is the index of machine and c is the index of the first core allocated on the machine. Otherwise, return (-1,-1). Once the cores are allocated,they cannot be used until they are freed.
2. Free the cores
allocated in the a-th query of the first type. We guarantee that the a-th query of the first type exists and each query is freed at most once. If the corresponding query didn't have a solution, you should just ignore it.
有Q次查询操作以如下两种类型执行：
1， Ask k个核，我们必须找到第一台（也就是序列最小的）拥有k个连续的可用核的机器，然后分配给客户。如果可行就返回（M，c）对，其中M为机器的索引，而c为这台机器里面这次请求到的第一个核的id；否则返回 (-1,-1)。一旦核被分配了，就不能再次分配（使用），直到被释放。
2、Free 核
释放之前第a次申请的核，我们保证上面的第a次申请操作是存在的，而且每次申请的核被一次释放。如果第a次申请么有成果，那么这次free应该被忽略。
赵4老师 2014-07-23
- 打赏
- 举报
欢迎楼主做一个有益于码农的村官。
就呆在云上 2014-07-23
- 打赏
- 举报
你这个机器翻译的？
晚点我给一个翻译吧。
赵4老师 2014-07-23
- 打赏
- 举报
有M个机器，其中，所述第i个机器有次芯（ⅰ从1开始）。在每台机器上，芯结构中的一行。
有以下类型的服务q查询：
1，问对k内核。我们必须找到与第一台机器（
至少指数），使得它有K个连续的无芯并为它们分配
给客户。如果有一个解决方案，返回结果（M，C），其中m
被机器和c的索引是第一核心的分配索引
在机器上。否则，返回（-1，-1）。一旦内核被分配
它们不能被使用，直至它们被释放。
2，释放的核
分配的所述第一类型的一个查询中。我们保证
所述第一类型的第a个查询存在与每个查询被释放至多
一次。如果相应的查询没有一个解决方案，你应该只
忽视它。
[输入参数]
第一行给出了一个整数T，测试用例的数量。
为
每个测试例中，第一行给出了M和Q，则M线跟随，每
其中包含一个数字，指示次为第i行。对于
接下来的Q行，他们每个人给出的查询。
1，A K。对应于查询的第一类型，k是请求的核心数。
2，F A。对应于第二类型的查询，一个指示第一类型的一个查询。
所有的数字都是整数。
[输出规格]
为
每个测试案例，第一输出线在此格式“案例＃我：”（不
引号），其中i是案件编号，从1开始，之后，
输出结果为1型的每个查询，无论是“MC”（不带引号），如果
有解决的查询，或“-1 -1”（不带引号），如果没有
解决方案找到。
[限制]
1<= T<=20
1<= M<=100000
1 <=次<=128
1<= Q<=百万
1<= K<=128
1<= A <= Q
类型1的查询的数量是相同的类型2。
就呆在云上 2014-07-23
- 打赏
- 举报
顶一下。
晚些时候贴个代码吧，没有代码估计都么有人愿意看这个问题。
