layout(poj3169)

1,我似乎找到了些。。彻底学习解决这些东西的方法。。

2，嗯。。这个关键是你怎么能转换成图的思想。。图的问题。。打眼一看，我觉得一般人肯定看不出来。。

3，这个要用的BELLMANFORD算法，所以赶紧学学搞个模板。

4，学习知识最简单的方法就是拿个例子给你讲。

嗯，模板让我感觉奇奇怪怪的。

5，还好这代码一遍就过了

#include<iostream>
#include<algorithm>
#define max 1005
//const int max=1005;
const int INF=100000005;
using namespace std;
int n,ml,md;
int al[max],bl[max],dl[max];
int ad[max],bd[max],dd[max];
int d[max];
bool updated;
void update(int& x,int y)
{
    if(x>y)
    {
        x=y;
        updated=true;
    }
}
void bellmanford()
{
    for(int k=0;k<=n;k++)
    {
        updated=false;
        for(int i=0;i+1<n;i++)
        {
            if(d[i+1]<INF)
                update(d[i],d[i+1]);
        }
        for(int i=0;i<ml;i++)
        {
            if(d[al[i]-1]<INF) 
                update(d[bl[i]-1],d[al[i]-1]+dl[i]);
        }
        for(int i=0;i<md;i++)
        {
            if(d[bd[i]-1]<INF) update(d[ad[i]-1],d[bd[i]-1]-dd[i]);
        }
    }
    
}
int main(){
    cin>>n>>ml>>md;
    for(int i=0;i<ml;i++){cin>>al[i]>>bl[i]>>dl[i];
    }
    for(int i=0;i<md;i++){cin>>ad[i]>>bd[i]>>dd[i];
    }
    fill(d,d+n,0);
    bellmanford();
    if(updated)
    {
        cout<<"-1"<<endl;
        return 0;
    }
    fill(d,d+n,INF);
    d[0]=0; 
    bellmanford();
    int res=d[n-1];
    if(res==INF) res=-2;
    cout<<res<<endl;
}

6，，努力转转可以变成线性规划问题哈哈哈哈

（若不等式的特点为所有的式子两边都只出现了一个变量，则这种特殊的不等式方程组又叫做差分约束系统）

7，代码里确实有个东西让我挺迷惑的

 

2、int&;

 

这里的&不是取地址符号，而是引用符号，引用是C++对C的一个重要补充。变量的引用就是

 

变量的别名，讲的通俗一点就是另外一个名字，比如：“张三这个人在家里，老爸老妈叫他

 

三娃子，那么这个三娃子就是指张三这个人，如果叫张三去做某事，就是叫三娃子去做某事，

 

这两个名字指的是同一个人。”同样可以理解如果变量b是变量a的引用 那么无论a，b中任

 

何一个值改变，另外一个也相应的改变，在声明一个引用时，必须同时使之初始化，即声

 

明它代表哪一个变量。请注意：由于引用不是独立的变量，编译系统不给它单独分配存

 

储单元，因此在建立引用时只有声明没有定义，只是声明它与原有的某一变量的关系。

 

在声明一个变量的引用后，在本函数执行期间，该引用一直与其代表的变量相联系，不能

 

再作为其他变量的别名。说得简单点：张三和三娃子是指同一个人，不能李四也叫三娃子，

 

如果可以这样，叫三娃子去做什么，是叫李四呢还是张三呢，这就会乱套了。所以在C++中

 

一个引用变量只能对应一个原始的变量，不能对应两个或多个原始的变量；

 

下面简单说明引用：

 

a)声明引用时必须指定它代表的是哪一个变量，即对它初始化。

 

int &a=b;这样是声明a是变量b的引用

 

如果是int &a;这样就是错的，没有指定a代表哪一个变量。

 

b)引用与其所代表的变量共享同一内存单元，系统并不为引用另外分配存储单元；

 

这个应该好理解；就像前面所说的，张三和三娃子都是同一个人，三娃子只是张三的别名。

 

因此，对于 int &a=b;这个例子来说，要输出a和b 的地址，肯定是相同的。

 

c)怎样区分&是引用还是取地址符呢？方法是：判断&a这样的形式前是否有类型符即

 

int &a=b;如果有类型符(int)则是引用，否则是取地址运算符。

 

d)对引用的初始化，可以是一个变量名，也可以是另一个引用。

 

换句话说：张三的别名可以是三娃子，三小子……及其他多个别名

 

而三娃子也可以有其他的别名，比如说：老三，小三等

 

用程序可以这样：

 

int a=1; //这里是定义一个整形变量

 

int &b=a;//声明b是整型变量a的别名

 

int &c=b;//声明c是整型引用变量b的别名

 

int &d=a;//声明d是整型变量a的别名

 

e)引用初始化后不能再被重新声明为另一变量的别名

 

即三娃子既然是指张三这个人，就不能让其他人也叫三娃子

 

即一个别名只能对应一个原始变量，但是一个原始变量可以有多个别名，而且别名也可以

 

由自己的别名。

 

 

 

C++中增加引用主要是作为函数参数，进行数据传递的功能；

 

我们知道如果用变量名作为实参，其传递方向是单向的，而用引用作为实参其传递方向

 

是双向的；

 

也许你会问，在c语言中不是有指针吗，用指针进行参数传递不也是双向的吗？其实其

 

本质上也是值传递，只不过是将变量的地址传给指针，通过指针获取变量的值，这样做

 

虽能得到结果，但通过指针运算符去访问有关变量，比较麻烦。

 

下面分析一下使用引用和使用指针变量作为函数形参的不同(以例子1中的swap函数为例)：

 

1、如果使用引用，则不必在swap函数设立指针变量，指针变量要另外开辟内存单元，其

 

内容是地址。而引用不是一个独立的变量，并不占用内存单元

 

2、在main函数中调用swap函数时实参不必再变量名前加&以表示地址，系统传递的是

 

实参的地址不是实参的值。

 

3、使用指针变量时，为了表示指针变量所指向的变量，必须使用指针运算符*，而使用

 

引用时，引用就代表该变量，不必使用指针运算符*；

 

4、用引用完成的工作，用指针也能完成。但引用比指针的使用直观、方便，直截了当，

 

不必“兜圈子”，容易理解。有些过去只能用指针来处理的问题，现在可以用引用来代替，

 

从而降低了程序设计的难度。

 

对引用进一步说明：

 

1、不能建立void类型的引用。

 

因为任何实际存在的变量都是属于非void类型的，void的含义是无类型或空类型，

 

void只是在语法上相当于一个类型而已。

 

2、不能建立引用的数组。

 

如：char c[6]="hello";

 

char &rc=c;//错误

 

因为数组名是数组首元素的地址，本身不是一个占有存储空间的变量。

 

3、可以将变量的引用的地址赋给一个指针，此时指针指向的是原来的变量。

 

这句话可以这样说：将引用变量的地址赋给一个指针，此时指针指向的是引用变量，

 

相当于指向原来的变量

 

int a=2;

 

int &b=a;//这个声明语句中的&是一个引用

 

int *p=&b;//这个指针初始化语句中的&是取地址运算符

 

上面一行等价于 int *p=&a;

 

但是不能定义指向引用类型的指针变量，不能写成

 

int & *p=&a;//企图定义指向引用类型的指针变量p，错误

 

因为引用不是一种独立的数据类型，因此不能建立指向引用类型的指针变量。

 

4、可以建立指针变量的引用如

 

int i=5;

 

int *p=&i;

 

int * &pt=p;//建立指针变量p的引用pt

 

引用变量pt代表一个int *类型的数据对象(即指针变量)

 

5、可以用const对引用加以限定，不允许直接改变该引用的值，但是可以改变原

 

变量的值去改变引用的值；

 

int i=5;

 

const int &a=i;

 

a=3;//错误，因为引用a是const int 类型不能直接改变引用的值

 

但是可以这样修改：

 

i=3;

 

此时输出i和a都是3

 

6、可以用常量或表达式对引用进行初始化，但此时必须用const作声明。

 

int i=5;

 

const int &a=i+1;

 

此时编译系统是这样处理的：生成一个临时变量，用来存放该表达式的值，引用是

 

该临时变量的别名、系统将“const int &a=i+1;”转换为

 

int temp=i+1;

 

const int &a=temp;

 

临时变量是在内部实现的，用户不能访问临时变量；

 

用这种办法不仅可以用表达式对引用进行初始化，还可以用不同类型的变量对之

 

初始化；如

 

double d=3.1415926;

 

const int &a=d;

 

以上等价为：

 

double d=3.1415926;

 

int temp=d;

 

const int &a=temp;

 

如果在上面不用const则会发生错误

 

double d=3.1415926;

总结一下就是双向的，反正值会变的那种

9，还是跟着你的套路来比较好。

不能这样，现在大概在值只最初实现了一遍样例的步骤上。