void LIFO_Stack::print(ostream &os)const
{
vector<elemtype>::const_reverse_iterator rit=_stack.rbegin(),rend=_stack.rend();
os<<"\n\t";
while(rit!=rend)
os<<*rit++<<"\n\t";
os<<endl;
}
cons_cell::cons_cell(vector<Cell> inCells)
: cell_t(kCellType_cons)
{
vector<Cell>::const_reverse_iterator iter;
for (iter = inCells.rbegin(); iter != (inCells.rend() - 1); ++iter) {
cdr = std::make_shared<cons_cell>(*iter, cdr);
}
}
bool solve(vector<pr> &vec,Graph &g){
sort(vec.rbegin(),vec.rend());
for(int i=0;i<vec.size();i++){
int s=vec[i].second;
if(g.BFS(s)) return true;
}
return false;
}
shared_ptr<ViewItem> Ruler::get_mouse_over_item(const QPoint &pt)
{
const vector< shared_ptr<TimeItem> > items(view_.time_items());
for (auto i = items.rbegin(); i != items.rend(); i++)
if ((*i)->enabled() && (*i)->label_rect(rect()).contains(pt))
return *i;
return nullptr;
}
vector<L> convex_hull(vector<L> v) {
if (v.size() <= 1)
return v;
sort(ALLOF(v), xy_less);
vector<L> cv;
walk_rightside(v.begin(), v.end(), cv);
walk_rightside(v.rbegin(), v.rend(), cv);
return cv;
}
int main() {
scanf("%d%d", &K, &N);
sticks.resize(N + 1);
sticks[0] = INF;
for (int i = 1; i <= N; i++) scanf("%lld", &sticks[i]);
sort(sticks.rbegin(), sticks.rend());
memset(cache, -1, sizeof(cache));
printf("%lld", minPenalites(N, K));
}
void sort(vector<int>& col)
{
//typedef vector<int>::reverse_iterator Iter;
for (auto i = col.rbegin(); i != col.rend(); ++i)
{
swap(*i, max(col.begin(), i.base()));
print(col);
}
}
void Output(ostream &outStrme, vector<Rec> &records, int limit)
{
std::sort(records.rbegin(), records.rend());
for (size_t i = 0; i < limit && i < records.size(); ++i) {
const Rec &rec = records[i];
outStrme << rec.line << endl;
}
}
string largestNumber(vector<int>& nums) {
sort(nums.begin(), nums.end(), my_comp_func);
ostringstream os;
for (auto it = nums.rbegin(); it != nums.rend(); it++)
os << *it;
if (os.str()[0] == '0')
return "0";
return os.str();
}
TrellisPath::TrellisPath(const vector<const Hypothesis*> edges)
:m_prevEdgeChanged(NOT_FOUND)
{
m_path.resize(edges.size());
copy(edges.rbegin(),edges.rend(),m_path.begin());
InitScore();
}
int main() {
int N, M; scanf("%d %d", &N, &M);
for(int i = 1; i <= N; i++) scanf("%lld", &C[i]);
while(M--) {
int u, v; scanf("%d %d", &u, &v);
G[u].push_back(v);
}
for(int i = 1; i <= N; i++) {
if(!vis[i]) dfs(i);
}
reverse(order.begin(), order.end());
long long ans = 0;
for(int i = 0; i <= N; i++) dp[i] = 0;
for(int i: order) {
dp[i] += C[i];
ans = max(ans, dp[i]);
for(int v: G[i]) {
dp[v] = max(dp[v], dp[i]);
}
}
printf("%lld\n", ans);
for(auto it = order.rbegin(); it != order.rend(); it++) {
int i = *it;
if(G[i].size() == 0) {
dp2[i] = dp[i];
dp3[i] = 0;
}
else {
dp2[i] = -1;
dp3[i] = LLONG_MAX/2;
for(auto u: G[i]) {
long long curr_inc = dp3[u] + (dp[u]-C[u]) - dp[i];
if(dp2[i] == -1) {
dp2[i] = dp2[u];
dp3[i] = curr_inc;
}
else {
if(dp3[i] - curr_inc > dp2[i] - dp2[u]) {
dp2[i] = dp2[u];
dp3[i] = curr_inc;
}
}
}
}
}
int Q; scanf("%d", &Q);
while(Q--) {
int u, d; scanf("%d %d", &u, &d);
printf("%lld\n", max(ans, dp2[u] + d - dp3[u]));
}
}
vector<vector<int> > subsets(vector<int>& nums)
{
// sort from big to small
sort(nums.rbegin(), nums.rend());
data = nums.begin();
vector<int> trace;
search(trace, nums.size() - 1);
return result;
}
void nextPermutation(vector<int>& nums) {
if (nums.size() <= 1)
return;
int maxnum = *nums.rbegin();
auto first = find_if(nums.rbegin(), nums.rend(), [&maxnum](int &num)
{ return num < maxnum ? true : (maxnum = num, false); });
if (first == nums.rend())
{
reverse(nums.begin(), nums.end());
}
else
{
auto second = find_if(nums.rbegin(), first, [&first](int &num)
{return num > *first; });
swap(*first, *second);
sort(nums.rbegin(), first, [](int &a, int &b){return a > b; });
}
}
vector<vector<int>> levelOrder(TreeNode* root) {
Traversal(0, root);
vector<vector<int> > reverse_answer;
vector<vector<int> >::reverse_iterator riter = ans.rbegin();
for (; riter != ans.rend(); riter++) {
reverse_answer.push_back(*riter);
}
return reverse_answer;
}
shared_ptr<ViewItem> Viewport::get_mouse_over_item(const QPoint &pt)
{
const vector< shared_ptr<ViewItem> > items(this->items());
for (auto i = items.rbegin(); i != items.rend(); i++)
if ((*i)->enabled() &&
(*i)->hit_box_rect(rect()).contains(pt))
return *i;
return nullptr;
}
int main()
{
cin.sync_with_stdio(false);
int C, N;
in >> C;
while (C--)
{
in >> N;
solution.clear();
isCycle = false;
aj = vector<vector<int>>(26, vector<int>());
vector<string> str(N);
for (auto &e : str)
in >> e;
for (int i = 1; i < N; i++)
{
string& p = str[i-1];
string& c = str[i];
int Len = min(p.size(), c.size());
for (int l = 0; l < Len; l++)
{
int P = p[l] - 'a';
int C = c[l] - 'a';
if (P != C)
{
aj[P].push_back(C);
break;
}
}
}
used = vector<bool>(26, false);
S = vector<bool>(26, false);
for (int i = 0; i < 26; i++)
if (!used[i]) dfs(i);
if (isCycle)
cout << "INVALID HYPOTHESIS" << endl;
else
{
for (auto e = solution.rbegin(); e != solution.rend(); ++e)
cout << (char)(*e + 'a');
cout << endl;
}
}
return 0;
}
int main()
{
int x;
int y;
int z;
int n;
float ans;
int p;
double temp;
int edges_count;
memset(adj, -1, sizeof(adj));
cout << "Enter number of tasks and pocessors\n";
cin >> tasks >> proc;
for (int i = 0; i < tasks; i++) {
temp = 0;
for (int j = 0; j < proc; j++) {
cin >> task_time[i][j];
temp += task_time[i][j];
}
avg[i] = (double) temp / (double) proc;
}
cout << "Number of edges for graph\n";
cin >> edges_count;
for (int i = 0; i < edges_count; i++) {
cin >> x >> y >> z;
adj[x][y] = z;
parent[y].push_back(x);
}
for (int i = 0; i < tasks; i++) {
rec_rank(i);
}
for (int i = 0; i < tasks; i++) {
rank_task.push_back(make_pair(rank[i], i));
}
sort(rank_task.rbegin(), rank_task.rend());
for (int i = 0; i < tasks; i++) {
}
heft();
return 0;
}
void calculate_beta(vector<uint8_t> const& sequence, hmm::hidden_markov_model<double> const& hmm,
vector<double> const& scaling, vector<row_vector>& betas)
{
size_t count = 0;
for (row_vector const& beta
: hmm::backward(sequence.rbegin(), sequence.rend(), scaling.rbegin(), hmm)) {
betas[sequence.size()-count-1] = beta;
++count;
}
}
void add(vector<int> &digits, int digit) {
int c = digit;
for_each(digits.rbegin(), digits.rend(), [&c](int &d) {
d += c;
c = d / 10;
d %= 10;
});
if (c > 0)
digits.insert(digits.begin(), 1);
}
vector<int> twoSum(vector<int>& nums, int target) {
vector<int> tmp(nums.begin(), nums.end());
std::sort(tmp.begin(), tmp.end());
int i = 0;
int j = tmp.size() - 1;
while(i < j) {
if(tmp[i] + tmp[j] == target) {
i = std::find(nums.begin(), nums.end(), tmp[i]) - nums.begin();
j = nums.rend() - std::find(nums.rbegin(), nums.rend(), tmp[j]) - 1;
return vector<int>{i,j};
}
else if(tmp[i] + tmp[j] > target) {
j--;
}
else {
i++;
}
}
}
shared_ptr<ViewItem> Header::get_mouse_over_item(const QPoint &pt)
{
const QRect r(0, 0, width() - BaselineOffset, height());
const vector<shared_ptr<TraceTreeItem>> items(
view_.list_by_type<TraceTreeItem>());
for (auto i = items.rbegin(); i != items.rend(); i++)
if ((*i)->enabled() && (*i)->label_rect(r).contains(pt))
return *i;
return shared_ptr<TraceTreeItem>();
}
void add(vector<int>& num, int digit){
int c = digit; // carry
for(auto it = num.rbegin(); it != num.rend(); it++){
*it += c;
c = *it / 10;
*it %= 10;
}
if (c != 0)
num.insert(num.begin(), 1);
}
vector<int> plusOne(vector<int>& digits) {
if(digits.size() == 0)
return digits;
vector<int>::reverse_iterator rit = digits.rbegin();
vector<int> returnedVector;
for( ;rit!= digits.rend(); ){
if(*rit == 9){
*rit = 0;
rit++;
if(rit == digits.rend()){
returnedVector.push_back(1);
}
}else{
*rit +=1;
break;
}
}
returnedVector.insert(returnedVector.end(),digits.begin(),digits.end());
return returnedVector;
}
void PosteriorEstimator::getQValuesFromPEP(const vector<double>& pep, vector<double> & q) {
int nP = 0;
double sum = 0.0;
// assuming pep sorted in decending order ?? sure?? //TOFIX
for (vector<double>::const_iterator myP = pep.begin(); myP != pep.end(); ++myP, ++nP) {
sum += *myP;
q.push_back(sum / (double)nP);
}
partial_sum(q.rbegin(), q.rend(), q.rbegin(), mymin);
return;
}
int greedy_fit(int in, vector<int> coins)
{
sort(coins.rbegin(), coins.rend());
int sum=0;
for(int i : coins)
{
if(sum+i<=in)sum+=i;
if(sum==in)return sum;
}
return sum;
}
// 0 <= digit <= 9
void add(vector<int> &digits, int digit) {
int c = digit; // carry, 进位
for (auto it = digits.rbegin(); it != digits.rend(); ++it) {
*it += c;
c = *it / 10;
*it %= 10;
}
if (c > 0)
digits.insert(digits.begin(), 1);
}
void PosteriorEstimator::getQValuesFromP(double pi0,
const vector<double>& p, vector<double> & q) {
double m = (double)p.size();
int nP = 1;
// assuming combined sorted in decending order
for (vector<double>::const_iterator myP = p.begin(); myP != p.end(); ++myP, ++nP) {
q.push_back((*myP * m * pi0) / (double)nP);
}
partial_sum(q.rbegin(), q.rend(), q.rbegin(), mymin);
return;
}
string check(vector <int> price, int budget, int k) {
sort(price.rbegin(), price.rend());
int i;
for (i = 0; i < k; ++i) {
budget -= price[i];
if (budget < 0) {
return "NO";
}
}
return "YES";
}
void printVectorRev(vector<string> strings)
{
vector<string>::reverse_iterator rstringIter;
for (rstringIter = strings.rbegin();
rstringIter != strings.rend();
rstringIter++)
{
cout << *rstringIter << " ";
}
cout << endl;
}
vector<int> plusOne(vector<int>& digits) {
int carry = 1;
for (vector<int>::reverse_iterator ri = digits.rbegin(); ri != digits.rend(); ++ri)
{
int digit = *ri + carry;
*ri = digit%10;
carry = digit/10;
}
if (carry != 0) digits.insert(digits.begin(), carry);
return digits;
}
