Q:

What is the difference between this implicit broadcast and the other way of doing the same via explicit broadcast?

With the two type of broadcast implicit and explicit broadcast in Android - for the implicit we would declare the broadcast in AndroidManifest.xml and when some app sends a broadcast with the action the all the apps which declares the broadcast in their manifest with that action would get invoked and do the job. 
With the background execution limits imposed by Android from O, I'm not allowed to send a broadcast only with the intent containing action. I must specify explicitly the package name and the receiving class name.
Now by doing something like this, I'm able to overcome the implicit broadcast limitation
String action = "com.android.intent.CUSTOM";
Intent intent = new Intent();
intent.setAction(intent);

//Though this is a deprecated method
List<ResolveInfo> resolvedBroadcasts = List<ResolveInfo> queryBroadcastReceivers(intent, 0, current_user_id);

for (ResolveInfo info : resolvedBroadcasts) {
   ServiceInfo serviceInfo = info.serviceInfo;

   //Note: Now this is becoming explicit broadcast
   intent.setAction(serviceInfo.packageName, serviceInfo.name);
   context.sendBroadcast(intent);
}

Am I missing something here? Got confused at this point like if I'm able to do this way then why Android imposed me this background execution limits?

A:

Am I missing something here?

Google engineers have indicated that if too many apps do this, this approach will be banned, somehow.
FWIW, I blogged about this approach two years ago.

if I'm able to do this way then why Android imposed me this background execution limits?

Google is hoping that few developers will employ this workaround and instead will use some other IPC mechanism.
The issue is process churn. Suppose that your implicit broadcast matches 25 apps' manifests. When your code executes, Android needs to pass your Intent to 25 receivers. However, only a couple of those will be in memory — many of the apps will not have running processes. So, Android now needs to fork a whole bunch of processes to deliver your Intent. That in turn is likely to force other processes to be terminated, to free up system RAM. The net result is poor performance on low-end devices.
I argued that, rather than ban implicit broadcasts, Android should implement a store-and-forward mechanism, slowly delivering the broadcast at a pace that will limit the process churn. My suggestion was rejected.

