AGGRCOW on SPOJ – Maximize the minimum distance between aggressive cows I am getting a TLE on my submission to AGGRCOW - Aggressive cows on SPOJ:


  Farmer John has built a new long barn, with N (2 &lt;= N &lt;= 100,000)
  stalls. The stalls are located along a straight line at positions
  x1,...,xN (0 &lt;= xi &lt;= 1,000,000,000).
  
  His C (2 &lt;= C &lt;= N) cows don't like this barn layout and become
  aggressive towards each other once put into a stall. To prevent the
  cows from hurting each other, FJ wants to assign the cows to the
  stalls, such that the minimum distance between any two of them is as
  large as possible. What is the largest minimum distance?
  
  Input
  
  t – the number of test cases, then t test cases follows.
  * Line 1: Two space-separated integers: N and C
  * Lines 2..N+1: Line i+1 contains an integer stall location, xi   
  
  Output  
  
  For each test case output one integer: the largest minimum distance.
  
  Example
  
  Input:

1
5 3
1
2
8
4
9

  
  Output:

3

  
  Output details:
  
  FJ can put his 3 cows in the stalls at positions 1, 4 and 8, 
  resulting in a minimum distance of 3.


I tried checking starting from smallest minimum distance i.e zero to the largest minimum distance that will be the solution. I used recursion to solve this question but getting TLE. How can I use binary search in this problem for making it more efficient.

#include&lt;bits/stdc++.h&gt;
using namespace std;

bool CanBeMin( vector&lt;long long int&gt; arr, unsigned int b,int s,unsigned int 
     cnt,long long int k){
           if(cnt == b ) return true;
           if(arr[s+1]=='\0') return false;
           for(unsigned int i=s+1 ; arr[i]!='\0'; i++){
                 if (arr[i] - arr[s] &gt; k &amp;&amp; b-cnt &lt;= arr.size() - i) { 
                            cnt ++;
                            return CanBeMin ( arr , b , i , cnt , k);}
                 }
                 return false;}

int count ( vector &lt;long long int&gt; arr, unsigned int b){
      long long int k=0;
      while (CanBeMin ( arr , b , 0 , 0 , k)) {
              k=k+1;}
      return k;}

int main(){
     int t;
     cin &gt;&gt; t;
     while ( t-- ){
         int a , b;
         cin &gt;&gt; a &gt;&gt; b;
         vector&lt;long long int&gt; arr(a);
             for( int i = 0; i &lt; a; i++) {
                 cin &gt;&gt; arr[i];}
         sort ( arr.begin(), arr.end());
         if (b &lt;= a)
         cout &lt;&lt; count (arr, b-1);
         else cout&lt;&lt;"0";
         cout &lt;&lt; endl; }
       }
Well, your indentation gives me a headache. I think there might be a pattern in it, but I don't see it, so I'll reformat it for writing my answer.
&lt;bits/stdc++.h&gt; is non-standard and causes longer compile-times. Maybe just include what you need?
Never use using namespace something_humungeous_and_growing_like_std;, because there might be conflicts, and silent changes of semantics.
There are single-character-names which would actually make sense for your variables: The ones used in the spec. If you don't want to use them, put a bit more effort into finding meaningful names.
You never test whether input succeeds. At the very least, add the following to get an exception (though it messes with the input-processing ordinarily used in bigger / more robust programs):

std::cin.exceptions(std::ios_base::failbit);

Avoid flushing streams (use '\n' instead of std::endl) unless you actually need to flush.
Prefer streaming character literals to size-1-strings. It's potentially marginally more efficient.
Decouple iostreams from stdio.
Refrain from copying expensive things. Every single time you pass your vector by value Needs a copy, thus a useless extra-allocation, -deallocation and block-copy.
Also, while it is generally a good idea to minimize the scope of variables, re-using the same vector over multiple iterations allows you to forego extra-allocations and de-allocations.
You are using extremely dumb brute-force in count() by trying minimal distances starting at zero and then counting up.
Consider using binary-search instead, trivial minimum is \$0\$, maximum is \$(maxpos - minpos) / (cows - 1)\$.
Same in CanBeMin(), use binary-search. std::lower_bound() can help.