应该先用数学方法得出公式，写程序就简单了

楼上说的真是至理名言，公式呢？

不太明白，下一个最打是什么，我的理解是F(13)=6,  F(14)=7,  F(21)=13....是这个意思吗

动态规划

是这个意思，求的是f(n)=n的n.

比如f(199981)=199981,要求找出这个199981来。

首先，确定最大的数。我们通过统计可以知道，9以下为：1个，99以下为：1*10+10*1=20个，999以下为：1*100+10*20=300个.n位数位n*100000(n-1个0）+10*（n-1位时的个数）。
得到最大位数为10.
然后，计算首位，当首位为1、2...，直到出现一个n,当首位为n时1个数小于n000000000,当为n+1时，1的个数大于(n+1)000000000,然后就这样推出整个数。

#include "stdafx.h"

#include <stdlib.h>

int f(int n);

int main(int argc, char* argv[])
{
  int n = 11;
  int i;
  if(argc>1)
    n = atoi(argv[1]);
  i = f(n);
printf("f(%d) = %d\n",n,i);
return 0;
}


int f(int n)
{
  int ret = 0;
  int ntemp=n;
  int ntemp2=1;
  int i=1;
  while(ntemp)
  {
    ret += (((ntemp-1)/10)+1) * i;
    if( (ntemp%10) <= 1 )
    {
      ret -= i;
    }
    if( (ntemp%10) ==1 )
    {
      ret += ntemp2;
    }
    ntemp = ntemp/10;
    i*=10;
    ntemp2 = n%i+1;
  }
  return ret;
}

高手，不是对手，赶紧走

只验证了几个数，包括199981

对求f（n）=n 除了从n=1开始穷举找还没想到好办法

if( (ntemp%10) <= 1 )
    {
      ret -= i;
    }
改成if( (ntemp%10) == 1 )
    {
      ret -= i;
    }

int f(int n)
{
  int ret = 0;
  int ntemp=n;
  int ntemp2=1;
  int i=1;
  while(ntemp)
  {
    ret += (((ntemp-1)/10)+1) * i;
    if( (ntemp%10) == 1 )
    {
      ret -= i;
      ret += ntemp2;
    }
    ntemp = ntemp/10;
    i*=10;
    ntemp2 = n%i+1;
  }
  return ret;
}

计算1111111110 219276ms 机器不是很好


unsigned int find1_2(unsigned int n)
{
unsigned int temp;
unsigned int count = 0;
for (unsigned int i = 1; i <= n; i++)
{
temp = i;
while(temp > 0)
{
if ( temp % 10 == 1 )
count++;
temp /= 10;
}
}
return count;
}

试了几个方法,这个算快的,期待高人.....

199991

#include <iostream>
#include <windows.h>
#include <ctime>
using namespace std;

unsigned long const len = 1111111110;

void main()
{
char buffer[20];
unsigned long counts = 0 , i, stringLength;
string s = "";
DWORD start, end, usetime;
start = GetTickCount();

for(i=1; i<=len; i++)
{
s += _itoa(i, buffer,10);
}

stringLength = s.length();

for(i=0; i<stringLength; i++)
{
if(s[i] == '1')
counts++;
}

cout<<"The counts of number 1 is : "<<counts<<endl;
end = GetTickCount();
usetime = start - end;
cout<<"use "<<usetime<<"milliseconds"<<endl;
}

恩
小弟利用了一个递归  f(n) = f(n-1) + ncount, ncount 是对数据本身种含有的 1 的个数的计算，
程序的效率不是很高，望指点 ~

int f(int a)
{
    int ncount = 0, i = 10;
    while (a%i < a)
    {
     if (a%i/(i/10) == 1) ncount++;
     i *= 10;
    }

    if (a%i/(i/10) == 1) ncount++;

    if (a == 1)
        return 1;
    else
        return f(a-1) + ncount;
}



main ()
{
int n;

printf("Please enter the num N :");
scanf("%d",&n);
printf("\n");

printf("f(n) is %d\n",f(n));

getch();
}

对于一位数而言 对N位整数能提供 10^(n-1)个1 
对于两位数，能提供10^（n-2）个1
对于m位数，能提供10^（n-m）个1
这其中111 11 11这种情况已经包含在内，不会重复。

这样作个第推，把他们相加，就能算出来了。

再优化一下：
#include <iostream>
#include <windows.h>
#include <ctime>
using namespace std;

unsigned long const len = 1111111110;

void main()
{
char buffer[20];
unsigned long counts = 0 , i, stringLength, j;
string s = "";
DWORD start, end, usetime;
start = GetTickCount();

for(i=1; i<=len; i++)
{
s = _itoa(i, buffer,10);
stringLength = s.length();
for(j=0; j<stringLength; j++)
{
if(s[j] == '1')
counts++;
}
}

cout<<"The counts of number 1 is : "<<counts<<endl;
end = GetTickCount();
usetime = start - end;
cout<<"use "<<usetime<<"milliseconds"<<endl;
}
好像和楼上几位的遍历每一位的算法复杂度差不多

哎 ~
虚无果然比较牛 ~    佩服 ！

我用过字符比较
结果花的时间是前面算法将近4倍 -_-!

在网吧先看看：-）

int f(int n)
{
if(0==n)return 0;
int temp=n,ret=0,i=0;
int a,b,c;
while(temp>0)
{
temp/=10;
i++;
}
temp=n;
while(temp>9)
{
if(1==i)a=1;
else a=(i-1)*(int)pow(10,i-2);
b=temp/(int)pow(10,i-1);
c=temp%(int)pow(10,i-1);
if(1==b)ret+=a+c+1;
else ret+=b*a+(int)pow(10,i-1);
temp=c;
i--;
}
if(temp>=1)ret++;
return ret;
}
有规律：
1~9出现1次；
1~99出现20次；
1~999出现300次；
.....
我的算出来f(1111111110)=1111111110;
只要十次循环……

#include "stdafx.h"
#include <iostream>
using namespace std;


int main(int argc, char* argv[])
{
unsigned n = 0;
int sum1= 0;
int n1 = 0;
for(int i10 = 0; i10 <= 9; i10++)
{
if(i10 == 1) n1 = 1;
else n1 = 0;
for(int i9 = 0; i9 <= 9; i9++)
{
if(i9 == 1) n1++;
else if( i9 == 2) n1--;
for(int i8 = 0; i8 <= 9; i8++)
{
if(i8 == 1) n1++;
else if( i8 == 2) n1--;
for(int i7 = 0; i7 <= 9; i7++)
{
if(i7 == 1) n1++;
else if( i7 == 2) n1--;
for(int i6 = 0; i6 <= 9; i6++)
{
if(i6 == 1) n1++;
else if( i6 == 2) n1--;
for(int i5 = 0; i5 <= 9; i5++)
{
if(i5 == 1) n1++;
else if( i5 == 2) n1--;
for(int i4 = 0; i4 <= 9; i4++)
{
if(i4 == 1) n1++;
else if(i4 == 2) n1--;
for(int i3 = 0; i3 <= 9; i3++)
{
if(i3 == 1) n1++;
else if(i3 == 2) n1--;
for(int i2 = 0; i2 <= 9; i2++)
{
if(i2 == 1) n1++;
else if(i2 == 2) n1--;
for(int i1 = 0; i1 <= 9; i1++)
{
if(i1 == 1) sum1 += 1;
sum1 += n1;
if(n == sum1) cout<<n<<"\n";
n++;
}
if(n > 1111111110) return 0;
}
}
}
}
}
}
}
}
}

return 0;
}

mark,明天来看

都是高手阿！！！

高手，不是对手，赶紧走

很容易的题目啊，数学归纳归纳即可。没什么难度。
谁还说动态规划啊```想超时吗？

给个题给大家做做咯``比这题难一些：

http://acm.pku.edu.cn/JudgeOnline/showproblem?problem_id=1019

真是高手云集~~~
收藏了~~~

对于这种大数的话，不该用递归，递归的开销太大了，效率就太太太太差劲了！

题目我都没有看懂
尤其是“返回0到n之间出现的"1"的个数”

等下给出Pascal和C++的源代码`

抱歉啊`来晚啦:

Pascal:
-----------------------------------------
program VivianSnow;
var i,j,k,l,m,n,s:int64;
begin
  readln(n);
  m:=0; s:=0; l:=1;
  while n>0 do
  begin
    inc(s,(n div 10)*l);
    if n mod 10>1 then inc(s,l) else
      if n mod 10=1 then inc(s,m+1);
    m:=m+(n mod 10)*l;
    n:=n div 10;
    l:=l*10;
  end;
  writeln(s);
end.

C++:
-----------------------------------------
#include <iostream>

using namespace std;

int main(){
    long long i,j,k,l,m,n,s;
    
    cin>>n;
    m=0; s=0; l=1;
    while (n>0){
          s+=(n/10)*l;
          if (n%10>1){s+=l;} 
            else if (n%10==1){s+=m+1;}
          m+=(n%10)*l;
          n=n/10;
          l=l*10; 
    }
    cout<<s<<endl;
    
    return 0;
}

以上算法对于输入长度为Len的n的时间复杂度为O(Len)，即为O(ln(n)/ln(10)+1)

呵呵，我也来凑个热闹。
算法的思想是一个递归，但不是上面
 jixingzhong(瞌睡虫（既然选择了远方,那就只有风雨兼程了！！）)的从0-N的递归
下面算法的递归层次是输入数据位数再减一，即输入7位数，只需要6层递归。
由于C++内部数据长度的问题，所输入的数据不能很大，应该在9位数以内都可以很快算出。
算法的思想明天再说。

#include <iostream.h>
#include <string.h>
#include <math.h>
#include <stdlib.h>
#define BUF_SIZE 255

unsigned long *gn;
int InitGn(int n);

unsigned long CountOne(char *str, int bits);

int main()
{
int len;
char buf[BUF_SIZE];
cout<<"Please input the number n: ";
cin>>buf;
len = strlen(buf);
gn = new unsigned long[len+1];
InitGn(len+1);
cout<<CountOne(buf,len)<<endl;
delete gn;
return 0;

}

unsigned long CountOne(char *buf, int bits)
{
  unsigned long subcount = 0;
  char *p = buf;
  if (bits == 1)
  {
if(*p >= '1')
return 1;
else
return 0;
  }
  if(*p == '0')
subcount = CountOne(++p, bits-1);
  else if(*p == '1')
  {
p++;
subcount = (atol(p) + 1) + gn[bits-1] + CountOne(p, bits-1);
  }
  else
  {
p++;
subcount = pow(10, bits-1) + (*buf - '0') * gn[bits-1] + CountOne(p, bits-1);
  }
  return subcount;
}

int InitGn(int n)
{
int subsum = 1;
gn[0] = 0;
for(int i=1; i<n; i++)
{
gn[i] = subsum + 10 * gn[i-1];
subsum *= 10;
}
return 0;
}

为什么递归啊？我的那个算法递推，应该是最快的算法，你能找出时间复杂度比O(ln(n)/ln(10)+1)的算法吗？

算法的思想是找出数字的每一位可能出现的1的次数，之和就是结果。

对于任何小于longint(long long)的数据，0.0001s 之内出结果

f(10^n - 1) = 10^(n-1) + f(10^(n-1)) * 10
f(9) = 1
f(99) = 20
f(999) = 300
f(9999) = 4000
f(99999) = 50000

就是最高为加1再乘以10

如果f(m)中m != 10^n - 1，则可以分解再做

楼上的说得太简单啦```对于数字为1的情况怎么处理？希望楼上编出程序写出来。

测试数据：
Please input the number n: 1
1
Please input the number n: 9
1
Please input the number n: 99
20
Please input the number n: 999
300
Please input the number n: 9999
4000
Please input the number n: 99999
50000
Please input the number n: 1111111110
1111111110
最后一个结果出来的非常快，1秒都不到。

可是楼上的算法太复杂，篇幅太大，编程复杂度很低，在这个角度说不是一个好算法。

呵呵，只是玩玩嘛。
Please input the number n: 1111111110
1111111110
Time elapsed: 0.000125174(s)
自己认为效率还可以。

说明一下我的算法：

说明一下我的算法：

Pascal:
-----------------------------------------
program VivianSnow;
var i,j,k,l,m,n,s:int64;
begin
  readln(n);  {输入n}
  m:=0; s:=0; l:=1;
  while n>0 do
  begin
    inc(s,(n div 10)*l);  {对于每一位加入起码的1的次数}
    if n mod 10>1 then inc(s,l) else  {如果前一位大于1的处理情况}
      if n mod 10=1 then inc(s,m+1);  {如果前一位等于1的处理情况}
    m:=m+(n mod 10)*l;  {形成后缀m}
    n:=n div 10;  {n减去最后一位}
    l:=l*10;  {数量级加一}
  end;
  writeln(s);
end.

C++:
-----------------------------------------
#include <iostream>

using namespace std;

int main(){
    long long i,j,k,l,m,n,s;
    
    cin>>n;  //输入n
    m=0; s=0; l=1;
    while (n>0){
          s+=(n/10)*l;  //对于每一位加入起码的1的次数
          if (n%10>1){s+=l;}   //如果前一位大于1的处理情况
            else if (n%10==1){s+=m+1;}  //如果前一位等于1的处理情况
          m+=(n%10)*l;  //形成后缀m
          n=n/10;  //n减去最后一位
          l=l*10;  //数量级加一
    }
    cout<<s<<endl;
    
    return 0;
}


这个算法没有递归，时间复杂度很低，且编程复杂度很低：
对于输入长度为Len的n的时间复杂度为O(Len)，即为O(ln(n)/ln(10)+1)
应该可以说是最快的算法
空间复杂度就不用说了，几个变量的空间
应该说此算法可取

牛，学习一下！

用同样的方法实测了一下，VivianSnow(Phoenix) 你的算法可没我的快啊。
对于1 111 111 110这个数，你的程序运行时间比我的长了7倍左右啊
你的程序运行时间差不多是
1111111110
1111111110
Time elapsed: 0.000752546
不清楚为什么。

输入：1111111110
运算时间：0.000000000000000000

这是那个算法Pascal形式运行的结果
任何数据的运行时间都远小于<0.0001

你没发现，我用的是long long吗？这比long int慢得多；Pascal一样，int64比longint慢得多。

你可以改成unsigned long int

我是用你的那个C++代码的，然后把long long改成long了，VC6不支持long long